feat(core,host,client): PyroWave datagram-aligned packets + partial-frame delivery (Phase 4, §4.4)

PyroWave AUs now packetize on the negotiated shard payload, so a lost datagram
costs a few wavelet blocks of localized blur rather than a whole frame — and the
client can render an aged-out lossy frame instead of freezing until the next one.

Host (opt-in, PyroWave only):
- The encoder packetizes at the shard payload behind a 4-byte window prefix
  (used-len u16 + kind u16). Whole packets pack into WIN_PACKED windows; a packet
  too large for one shard (PyroWave 32x32 blocks are atomic and can exceed a
  shard) rides a WIN_FRAG_FIRST/CONT/LAST chain. `set_wire_chunking()` joins the
  Encoder trait (forwarded through TrackedEncoder — the silent-no-op trap);
  EncodedFrame.chunk_aligned marks the AU.
- virtual_stream tags the AU with USER_FLAG_CHUNK_ALIGNED and re-applies chunking
  after every encoder (re)build, the adaptive-bitrate rebuild included.

Core:
- USER_FLAG_CHUNK_ALIGNED (0x40) wire bit. Reassembler opt-in
  (set_deliver_partial): a chunk-aligned frame that ages out with holes is handed
  over as Frame{complete:false} — received shards at their exact offsets, missing
  ranges zero-filled — instead of being dropped. Partials age out on a tight 30ms
  fuse (PARTIAL_WINDOW_NS) instead of the 120ms loss window: each frame is
  independently decodable, so an ancient partial has no value in a live stream.
  Newest-wins. A partial still counts as dropped for loss reporting.

Client (PyroWave decode):
- The session opts in when codec == PyroWave. The decoder walks the AU
  window-by-window, skipping zero (missing) windows and reassembling FRAG chains,
  then decodes whatever survived. A newest-decoded-index guard drops partials the
  pump has already moved past (no time-travel present).

Also fixes a redundant-closure clippy nit in the PyroWave planar-present path.

Validated on an RTX 5070 Ti under 2% netem loss with FEC pinned off: 60fps
sustained entirely via partials, e2e 43ms p50 (146ms before the fuse) vs 23ms
lossless, no keyframe-recovery chatter. Tests green: core 149, host 310 + the
GPU-gated encoder smoke (framed-window walk + FRAG reassembly + upstream
round-trip), client 26; clippy clean on the pyrowave feature combos.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

crates/punktfunk-core/src/client.rs

@@ -71,6 +71,8 @@ enum CtrlRequest {
 #[derive(Clone, Copy)]
 struct Negotiated {
     mode: Mode,
+    /// Wire shard payload — the chunk-aligned parse window (plan §4.4).
+    shard_payload: u16,
     compositor: CompositorPref,
     gamepad: GamepadPref,
     /// SHA-256 of the certificate the host actually presented (TOFU callers persist this).
@@ -513,6 +515,9 @@ pub struct NativeClient {
     /// requested rate clamped to the host's range, or its default if we requested `0`. `0` = an
     /// older host that didn't report it.
     pub resolved_bitrate_kbps: u32,
+    /// The session's wire shard payload (bytes of AU per datagram) — the parse-window size
+    /// for chunk-aligned AUs ([`crate::packet::USER_FLAG_CHUNK_ALIGNED`], plan §4.4).
+    pub shard_payload: u16,
     /// Host clock minus client clock (ns), from the connect-time skew handshake. Add it to a local
     /// receive/present timestamp to express it in the host's capture clock (the AU `pts_ns`), making
     /// glass-to-glass latency valid across machines. `0` = no correction (an old host that didn't
@@ -778,6 +783,7 @@ impl NativeClient {
             resolved_compositor: negotiated.compositor,
             resolved_gamepad: negotiated.gamepad,
             resolved_bitrate_kbps: negotiated.bitrate_kbps,
+            shard_payload: negotiated.shard_payload,
             clock_offset_ns: negotiated.clock_offset_ns,
             bit_depth: negotiated.bit_depth,
             color: negotiated.color,
@@ -1540,7 +1546,14 @@ async fn worker_main(args: WorkerArgs) {
             if let Ok(sock) = transport.try_clone_socket() {
                 crate::transport::spawn_data_punch(sock, shutdown.clone());
             }
-            let session = Session::new(welcome.session_config(Role::Client), Box::new(transport))?;
+            let mut session =
+                Session::new(welcome.session_config(Role::Client), Box::new(transport))?;
+            // PyroWave sessions opt into partial delivery (plan §4.4): an aged-out lossy
+            // frame arrives as blocks-with-holes instead of vanishing — the all-intra codec
+            // renders it as one frame of localized blur, strictly better than a freeze.
+            if welcome.codec == crate::quic::CODEC_PYROWAVE {
+                session.set_deliver_partial_frames(true);
+            }
             Ok::<_, PunktfunkError>((
                 session,
                 send,
@@ -1558,6 +1571,7 @@ async fn worker_main(args: WorkerArgs) {
                     chroma_format: welcome.chroma_format,
                     audio_channels: welcome.audio_channels,
                     codec: welcome.codec,
+                    shard_payload: welcome.shard_payload,
                 },
                 welcome.host_caps,
             ))
@@ -2490,6 +2504,7 @@ mod frame_channel_tests {
             frame_index: i,
             pts_ns: i as u64,
             flags: 0,
+            complete: true,
         }
     }