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/gamepad.rs

@@ -31,11 +31,8 @@ const G: f32 = 9.80665;
 
 #[derive(Clone, Debug)]
 pub struct PadInfo {
-    // `id`/`name` feed the settings GUI's pad list (a follow-up); the windowed client only
-    // reads `pref` (via `auto_pref`), so they're unused in reachable code for now.
-    #[allow(dead_code)]
+    /// SDL joystick instance id — the settings GUI's pin key.
     pub id: u32,
-    #[allow(dead_code)]
     pub name: String,
     /// The virtual pad "Automatic" resolves to for this physical controller (DualSense → DualSense,
     /// DS4 → DualShock 4, Xbox One/Series → Xbox One, else → Xbox 360).
@@ -48,6 +45,19 @@ impl PadInfo {
     fn is_dualsense(&self) -> bool {
         self.pref == GamepadPref::DualSense
     }
+
+    /// A short human label for the detected pad family, shown next to the name in the settings
+    /// GUI's controller list ("" for a generic pad the name already describes).
+    pub fn kind_label(&self) -> &'static str {
+        match self.pref {
+            GamepadPref::DualSense => "DualSense",
+            GamepadPref::DualShock4 => "DualShock 4",
+            GamepadPref::XboxOne => "Xbox One",
+            GamepadPref::SteamDeck => "Steam Deck",
+            GamepadPref::SteamController => "Steam Controller",
+            _ => "",
+        }
+    }
 }
 
 /// Map the SDL-reported controller type to the virtual pad we'd ask the host to create.
@@ -102,7 +112,7 @@ impl GamepadService {
         }
     }
 
-    #[allow(dead_code)] // consumed by the settings GUI (follow-up)
+    /// Connected controllers, most recently attached first (the settings GUI's list order).
     pub fn pads(&self) -> Vec<PadInfo> {
         self.pads.lock().unwrap().clone()
     }
@@ -111,12 +121,11 @@ impl GamepadService {
         self.active.lock().unwrap().clone()
     }
 
-    #[allow(dead_code)] // consumed by the settings GUI (follow-up)
+    /// The user-pinned controller (settings GUI), if any — else auto (most recent).
     pub fn pinned(&self) -> Option<u32> {
         *self.pinned.lock().unwrap()
     }
 
-    #[allow(dead_code)] // consumed by the settings GUI (follow-up)
     pub fn set_pinned(&self, id: Option<u32>) {
         let _ = self.ctl.lock().unwrap().send(Ctl::Pin(id));
     }