refactor(core/W7): split client.rs into client/ facade + submodules

Turn the 2674-line client.rs into a client/ directory module (mod.rs facade +
8 submodules) behind glob/`use self::` re-exports, so crate::client::X paths
(NativeClient, ProbeOutcome, AudioPacket, display_hdr_env_override) stay
byte-stable. Leaf lifts: frame_channel.rs (the FIFO hand-off + jump-to-live
consts + DecodeLatAcc), recovery.rs (RfiRecovery loss-range detector),
probe.rs (ProbeState/ProbeOutcome), planes.rs (side-plane queues + AudioPacket),
control.rs (CtrlRequest/Negotiated), worker.rs (WorkerArgs + reject_from_close),
pairing.rs (NativeClient::pair). The per-frame pump moves WHOLE as a plain
`pub(super) async fn run_pump` (was worker_main) — the only edit is the
signature line: no trait object, no Box, no per-frame allocation or indirection.
NativeClient + its public impl + Drop + the cfg-gated thread-pin/hot-tid helpers
stay in the facade. Visibility bumps are pub(crate) (struct + each field for
WorkerArgs/Negotiated/ProbeState; FrameChannel + each method); reject_from_close
is pub(crate) (sibling access). No behavior change.

Verified: Linux clippy (quic + no-default, -D warnings) + full cargo test;
Windows clippy (both) + test --lib; macOS clippy (apple thread-pin variant) +
165 lib tests. On-glass jump-to-live + ABR smoke still owed (pump is a pure
relocation, so this is a formality) per the plan's pump gate.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

crates/punktfunk-core/src/client/worker.rs

@@ -0,0 +1,67 @@
+//! `WorkerArgs` (the pump's constructor payload) and `reject_from_close`.
+
+use super::*;
+use crate::config::{CompositorPref, GamepadPref, Mode};
+use crate::error::Result;
+use crate::input::InputEvent;
+use crate::quic::{HdrMeta, HidOutput, RichInput};
+use std::sync::atomic::{AtomicBool, AtomicI64, AtomicU64};
+use std::sync::mpsc::SyncSender;
+use std::sync::{Arc, Mutex};
+
+pub(crate) struct WorkerArgs {
+    pub(crate) host: String,
+    pub(crate) port: u16,
+    pub(crate) mode: Mode,
+    pub(crate) compositor: CompositorPref,
+    pub(crate) gamepad: GamepadPref,
+    pub(crate) bitrate_kbps: u32,
+    pub(crate) video_caps: u8,
+    pub(crate) audio_channels: u8,
+    pub(crate) video_codecs: u8,
+    pub(crate) preferred_codec: u8,
+    pub(crate) display_hdr: Option<HdrMeta>,
+    pub(crate) launch: Option<String>,
+    pub(crate) pin: Option<[u8; 32]>,
+    pub(crate) identity: Option<(String, String)>,
+    pub(crate) frames: Arc<FrameChannel>,
+    pub(crate) audio_tx: SyncSender<AudioPacket>,
+    pub(crate) rumble_tx: SyncSender<RumbleUpdate>,
+    pub(crate) hidout_tx: SyncSender<HidOutput>,
+    pub(crate) hdr_meta_tx: SyncSender<HdrMeta>,
+    pub(crate) host_timing_tx: SyncSender<crate::quic::HostTiming>,
+    pub(crate) input_rx: tokio::sync::mpsc::UnboundedReceiver<InputEvent>,
+    pub(crate) mic_rx: tokio::sync::mpsc::Receiver<(u32, u64, Vec<u8>)>,
+    pub(crate) rich_input_rx: tokio::sync::mpsc::UnboundedReceiver<RichInput>,
+    pub(crate) ctrl_rx: tokio::sync::mpsc::Receiver<CtrlRequest>,
+    pub(crate) ctrl_tx: tokio::sync::mpsc::Sender<CtrlRequest>,
+    pub(crate) ready_tx: std::sync::mpsc::Sender<Result<Negotiated>>,
+    pub(crate) shutdown: Arc<AtomicBool>,
+    /// Deliberate-quit flag (see [`NativeClient::quit`]): the worker closes with the quit code if set.
+    pub(crate) quit: Arc<AtomicBool>,
+    pub(crate) mode_slot: Arc<std::sync::Mutex<Mode>>,
+    pub(crate) probe: Arc<Mutex<ProbeState>>,
+    pub(crate) frames_dropped: Arc<AtomicU64>,
+    pub(crate) fec_recovered: Arc<AtomicU64>,
+    pub(crate) hot_tids: Arc<Mutex<Vec<i32>>>,
+    /// The live clock offset (see [`NativeClient::clock_offset`]): the worker seeds it with the
+    /// connect-time estimate; the control task's mid-stream re-syncs update it.
+    pub(crate) clock_offset: Arc<AtomicI64>,
+    /// Decode-stage latency samples from the embedder (see [`NativeClient::decode_lat`]): the pump
+    /// drains a window mean into the adaptive-bitrate controller's decode signal.
+    pub(crate) decode_lat: Arc<Mutex<DecodeLatAcc>>,
+}
+
+/// The worker: QUIC handshake, then the input/datagram/control tasks + the blocking
+/// data-plane pump.
+/// The host's stated rejection, if this connection was closed with a typed application code
+/// (see [`crate::reject`]) — `None` for local errors, bare/legacy closes (including our own
+/// `LocallyClosed`), and transport failures, which keep their original error.
+pub(crate) fn reject_from_close(conn: &quinn::Connection) -> Option<crate::reject::RejectReason> {
+    match conn.close_reason()? {
+        quinn::ConnectionError::ApplicationClosed(ac) => u32::try_from(u64::from(ac.error_code))
+            .ok()
+            .and_then(crate::reject::RejectReason::from_close_code),
+        _ => None,
+    }
+}