feat(launcher): native Windows support

Port the egui launcher to run natively on Windows (no Wine/Proton). The GUI,
launch state machine, config, health/account monitors, and openfut.cfg writing
are unchanged and cross-platform; only the effect layer is branched:

- game_launch: cfg(windows) launch spawns the game executable directly with its
  working dir (the version.dll hijack loads from the game dir; no WINEDLLOVERRIDES,
  Wine prefix, or licence regen). Requires the launcher to run elevated so the
  child inherits admin. Linux Proton path gated cfg(unix).
- arm: cfg(windows) is a no-op (routing is openfut.cfg, written by the client-files
  step; no ptrace_scope/DNAT/hosts). Linux arming gated cfg(unix).
- local_services: on Windows LSX/autopatch are in-process (stp-origin_emu.dll +
  version.dll hook), so ensure_running reports ready without spawning. Gated the
  unix-only CommandExt/process_group.
- preflight: cfg(windows) run() keeps only backend-reachable + hook-config checks.
- config: GameProfile configured()/validate() accept a runner-less Windows profile.

theme: fix a latent cross-platform panic — egui 0.29 keeps a Style per theme, so
set_style only reached the active one and TextStyle::resolve("Hero") panicked when
the other theme rendered. Install the full style into both themes and pin Dark.

Cross-built for x86_64-pc-windows-gnu; Linux build + 75 tests unchanged.

src/preflight.rs

@@ -31,6 +31,7 @@ use std::time::Duration;
 use crate::config::LauncherConfig;
 
 const PROBE_TIMEOUT: Duration = Duration::from_secs(2);
+#[cfg(unix)]
 const PTRACE_SCOPE: &str = "/proc/sys/kernel/yama/ptrace_scope";
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -86,6 +87,7 @@ impl Check {
 }
 
 /// Run every applicable check. Order is the order the game exercises them.
+#[cfg(unix)]
 pub fn run(cfg: &LauncherConfig) -> Vec<Check> {
     vec![
         ptrace_scope(),
@@ -96,6 +98,16 @@ pub fn run(cfg: &LauncherConfig) -> Vec<Check> {
     ]
 }
 
+/// On native Windows the client-preparation checks (ptrace_scope, the EA
+/// redirector DNAT, `/etc/hosts`) do not apply: there is no host to arm and
+/// routing is entirely the `openfut.cfg` the hook reads. Only the two the game
+/// truly depends on remain: the backend is reachable and the deployed hook
+/// config agrees with the launcher's settings.
+#[cfg(windows)]
+pub fn run(cfg: &LauncherConfig) -> Vec<Check> {
+    vec![backend_reachable(cfg), hook_config(cfg)]
+}
+
 /// Checks that will stop the game working.
 pub fn failures(checks: &[Check]) -> usize {
     checks.iter().filter(|c| c.state == State::Fail).count()
@@ -113,6 +125,7 @@ pub fn warnings(checks: &[Check]) -> usize {
 /// Unconditional. autopatch is a workspace binary that ships alongside the
 /// launcher, so there is no configuration that could make this inapplicable —
 /// every launch runs it.
+#[cfg(unix)]
 fn ptrace_scope() -> Check {
     const NAME: &str = "ptrace_scope (autopatch)";
     match std::fs::read_to_string(PTRACE_SCOPE) {
@@ -127,6 +140,7 @@ fn ptrace_scope() -> Check {
 /// Reading `/proc` in a test would assert facts about the machine running the
 /// suite rather than about this code — and left inline, "any value is fine"
 /// was a mutation no test could catch.
+#[cfg(unix)]
 fn ptrace_verdict(raw: &str) -> Check {
     const NAME: &str = "ptrace_scope (autopatch)";
     let v = raw.trim();
@@ -146,6 +160,7 @@ fn ptrace_verdict(raw: &str) -> Check {
 ///
 /// This tests the *effect* rather than reading firewall rules, so it needs no
 /// privilege and stays honest about what the game will actually experience.
+#[cfg(unix)]
 fn ea_redirect(cfg: &LauncherConfig) -> Check {
     const NAME: &str = "EA redirector IP is redirected";
     let ip = cfg.ea_redirect_probe_ip.trim();
@@ -184,6 +199,7 @@ fn ea_redirect(cfg: &LauncherConfig) -> Check {
 /// So this is a real misconfiguration worth fixing and not a reason to expect
 /// failure. Reporting it as fatal, and then being contradicted by a working
 /// game, is how a checklist trains its user to ignore it.
+#[cfg(unix)]
 fn hostname_mapping(cfg: &LauncherConfig) -> Check {
     const NAME: &str = "EA hostnames point at OpenFUT";
     if cfg.ea_hostnames.is_empty() {
@@ -320,7 +336,7 @@ fn join(ips: &[IpAddr]) -> String {
         .join(",")
 }
 
-#[cfg(test)]
+#[cfg(all(test, unix))]
 mod tests {
     use super::*;