feat(clients/windows): screen-module restructure + parity features (speed test, native mode, capture UX)

Structure: split the 1400-line app.rs into per-screen app/ modules (mod=root/
router, hosts, connect, pair, speed, settings, licenses, stream, style) with
shared card/header/busy-page builders and setting_combo/toggle helpers; the
re-render rule (thread-driven state lives in root use_async_state, flows down
as props) is now documented at the module root.

Parity features the other clients already had:
- "Native display" resolves the real monitor mode at connect
  (MonitorFromWindow -> EnumDisplaySettingsW; was a hardcoded 1080p60)
- per-host network speed test: saved-host card button + a results screen
  (probe burst -> goodput/loss -> ~70% recommended bitrate applied in one
  tap; stale runs invalidated by generation) and `--headless --speed-test`;
  the bitrate setting becomes a free-form NumberBox so the recommendation
  round-trips
- forget host (ContentDialog confirm -> KnownHosts::remove_by_fp)
- settings: forwarded-controller picker (pads/pinned/set_pinned now wired),
  gamepad type, host compositor, capture-system-shortcuts; the previously
  dead Settings.compositor / inhibit_shortcuts are honored (shortcuts off =
  Alt+Tab/Alt+Esc/Ctrl+Esc/Win act locally)
- click-to-recapture after a Ctrl+Alt+Shift+Q release; the HUD hint tracks
  the live capture state

Perf: the input hook caches lock geometry (clip rect + contain-fit scale) at
engage instead of GetClientRect per WM_MOUSEMOVE; the audio jitter ring trims
via drain() and reuses the render scratch buffer.

Validated on the bare-metal box: --discover, synthetic-host loopback E2E
(TOFU -> clock skew -> HEVC negotiate -> D3D11VA init -> session end),
speed-test E2E, and the WinUI shell rendering in the console session via
PsExec (SSH/session-0 cannot create windows, pre-existing 0x80070005).

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

clients/windows/src/audio.rs

@@ -138,6 +138,7 @@ fn render_thread(
         // Adaptive jitter buffer, in f32-byte units (same shape as the host's virtual mic).
         let mut ring: VecDeque<u8> = VecDeque::new();
         let mut primed = false;
+        let mut out = Vec::new(); // per-quantum scratch, reused across iterations
 
         while !stop.load(Ordering::Relaxed) {
             if h_event.wait_for_event(100).is_err() {
@@ -159,14 +160,16 @@ fn render_thread(
 
             // Prime to ~3 quanta; cap at ~1 quantum of slack beyond that; re-prime on drain.
             let target = (3 * want_bytes).clamp(720 * block_align, 9600 * block_align);
-            while ring.len() > target.max(want_bytes) + want_bytes {
-                ring.pop_front();
+            let cap = target.max(want_bytes) + want_bytes;
+            if ring.len() > cap {
+                ring.drain(..ring.len() - cap);
             }
             if !primed && ring.len() >= target {
                 primed = true;
             }
 
-            let mut out = vec![0u8; want_bytes];
+            out.clear();
+            out.resize(want_bytes, 0);
             if primed {
                 let n = ring.len().min(want_bytes);
                 for (dst, b) in out.iter_mut().zip(ring.drain(..n)) {