Adopt StreamingAsrEngine in voxora-qwen3asr (waiting on candle incremental decoding)

Tracks the work to implement `voxora_traits::StreamingAsrEngine`
in `voxora-qwen3asr`. The trait surface was added in voxora 0.3.0
(PR #38) but no engine implements it yet.

## Status

**Blocked on upstream.** `qwen3-asr` 0.2.x (and the underlying
`candle-core` 0.9) does not currently expose incremental
decoding for the Qwen3-ASR architecture. Qwen3-ASR is an
encoder-decoder model; streaming would require either
encoder-state streaming (not currently exposed) or window-based
re-decoding with overlap (which would multiply cost).

Possible unblockers:
- `candle` adds a `forward_step` or similar that exposes
incremental encoder state.
- A pure-Rust re-implementation of the Qwen3-ASR decoder that
supports chunked decoding natively.

## What implementing looks like

In `voxora-qwen3asr/src/engine.rs`:

\`\`\`rust
use voxora_traits::StreamingAsrEngine;
use voxora_traits::StreamingOptions;
use voxora_traits::StreamingResult;
use voxora_traits::StreamingSession;

impl StreamingAsrEngine for QwenAsrEngine {
async fn begin_stream(&self, opts: &StreamingOptions) -> Result, AsrError> {
// Acquire a streaming state if upstream supports it.
// Otherwise return AsrError::Unsupported(\"streaming\") with a
// clear \"requires upstream candle/qwen3-asr with incremental
// decoding\" message.
}
}
\`\`\`

In `voxora-qwen3asr/src/lib.rs`: gate the streaming impl behind a
`streaming` Cargo feature, off by default.

## Acceptance

- `voxora-qwen3asr 0.X.0` published with a `streaming` feature
flag (default off).
- When the feature is on AND upstream supports incremental
decoding, `QwenAsrEngine::adapter()` returns an `EngineAdapter`
whose `as_streaming_engine()` returns `Some(...)`.
- When the feature is on BUT upstream does NOT support
incremental decoding, `begin_stream` returns
`AsrError::Unsupported` with a clear message.
- A streaming parity test (only enabled when the feature is on
AND upstream supports it).

## Out of scope

- Re-implementing the Qwen3-ASR architecture in voxora itself. The
engine delegates to upstream; this issue is purely about wiring.