moq-lite-05: implement FETCH for past groups via TrackConsumer::fetch

[kixelated]

What

Adds a one-shot fetch on TrackConsumer, so you can retrieve a single past group without holding a live subscription:

TrackConsumer::fetch(sequence: u64, options: impl Into<Option<Fetch>>) -> Result<TrackFetchPending>
pub struct Fetch { pub priority: u8 }   // defaults priority 0

TrackFetchPending resolves to a GroupConsumer: immediately if the group is already cached, otherwise after a wire moq-lite FETCH completes (blocking on a new FETCH_OK, mirroring how subscribe blocks on SUBSCRIBE_OK). FETCH was previously a wire-only definition the publisher rejected with UnexpectedStream.

Why

The only way to read a group was to subscribe to a track and walk its cache. There was no first-class way to grab one past group. fetch lives on TrackConsumer (not a live subscription) on purpose: you no longer have to subscribe just to fetch.

How it works (model)

Fetch fits the track model right where the // TODO fetch placeholders were:

• TrackConsumer::fetch(sequence, options) registers a want in the track's shared state (only if the group isn't already determined by the cache) and returns a TrackFetchPending that resolves via poll_get_group.
• Producer side — a relay learns of fetch requests via TrackRequest::requested_fetch() (pre-accept) / TrackProducer::requested_fetch() (post-accept), then makes the group available with TrackRequest::serve_fetch(sequence, timescale) -> GroupProducer (which doesn't require the track to be accepted, so a fetch-only track needs no TrackInfo).
• A cached group resolves with no wire round-trip; an aborted/evicted group goes to the wire.

The FETCH response streams on the same bidi control stream as the request: subscriber writes Fetch; publisher replies FetchOk (codec + timescale) then streams the group's frames; stream FIN ends the group. Errors propagate via stream reset.

Changes

• model (model/track.rs): Fetch options + FetchRequest; TrackConsumer::fetch → TrackFetchPending; TrackState.fetches; producer/request requested_fetch() + TrackRequest::serve_fetch(). GroupConsumer::timescale() accessor (model/group.rs).
• wire (lite/fetch.rs): new FetchOk (group echo + compression + timescale); Fetch.frame_start (lite-05+, honored by the publisher).
• publisher (lite/publisher.rs): recv_fetch / run_fetch serve the group on the fetch stream (gated to lite-05+).
• subscriber (lite/subscriber.rs): run_subscribe is now a demand loop that serves both subscriptions and fetches off one TrackRequest; a fetch opens a wire FETCH upstream and fills the group (spawned).
• kio (kio/producer.rs): expose poll_unused (poll sibling of the existing async unused), used by the relay's demand loop to stop serving a track once every consumer drops.
• relay (moq-relay/src/web.rs): GET /fetch/<broadcast>/<track>?group=N uses fetch() instead of subscribe(). ?group=latest keeps the subscribe path (fetch needs a concrete group).

Out of scope (follow-ups)

• frame_start resume reseed. The publisher honors frame_start on the wire, but fetch() always requests 0; an aborted/evicted group is re-fetched whole. True resume (request frame_start = N, stitch onto cached frames) is a separate change.
• Compressed fetch. v1 streams fetched groups uncompressed (FetchOk.compression = None).
• Fetch of an old group while already subscribed. The subscribe lifecycle loop doesn't watch for fetch requests, so a fetch of an evicted group on an actively-subscribed track isn't served (recent groups still resolve from cache). Easy to add later.
• JS + docs. Cross-Package Sync pairs rs/moq-net wire/API with js/net and doc/concept; deferred.

Test plan

• cargo test -p moq-net — wire roundtrip (FetchOk, frame_start gating) + model unit tests (cache hit, miss-signals-producer, past-final NotFound, abort).
• cargo test -p moq-native --test broadcast — broadcast_moq_lite_05_fetch_webtransport: end-to-end fetch over a real session (client fetches a past group; the relay forwards a wire FETCH upstream). WebTransport only, since Lite05Wip isn't ALPN-advertised.
• cargo test -p moq-relay -p kio, cargo clippy --workspace, cargo fmt --check.

Targets dev per branch targeting (wire-protocol + model change under rs/moq-net). Rebased onto the TrackInfo / async-TrackConsumer reshape (#1631) and the frame_start wire field (#1595).

🤖 Generated with Claude Code

(Written by Claude)