launcher: guided first-run flow, server-owned settings, hook-config reconcile

Release-readiness pass on the launcher, driven by the end state "open it,
create an account, launch the game".

Fixes a silent correctness bug. `openfut.cfg` in the game dir is the only
server address the *game* can see, but it was written only by Setup's deploy
and its "Save & Update hook" button. Changing the server anywhere else left
FIFA connecting to the previous host while every panel in the launcher showed
the new one online. Now:

  - `write_hook_config` reconciles the file from the live config, and runs
    fail-closed before every launch, so the file and the UI cannot disagree at
    the moment it matters;
  - saving Settings pushes the address into the hook immediately;
  - a `hook_config` preflight check reads the file back and warns, naming both
    addresses, instead of leaving the drift invisible;
  - Settings shows the same fact inline, and Save is enabled by drift alone —
    a message saying "Save to update it" beside a disabled button is a dead end.

Account creation is now server-authoritative. `account_sync::discover` POSTs
`/openfut/account/sync` with the persona fields *omitted*, which makes the host
answer with the persona it was started with, its club, and the Core coin
balance. The launcher adopts that answer, so it never invents an identity and
the persona the game authenticates with is by construction the one the server
expects. Claiming is gated on the address being valid, NOT on the health pill:
that pill probes the HTTPS port while this talks to the account port, so gating
on it disabled the button on servers that answer it perfectly well.

UX consolidation:

  - new Welcome ("Get started") tab: three numbered steps — connect, claim an
    account, connect FIFA — each showing live state, ending in the launch CTA;
    a fresh install opens on it and it leaves the nav rail once satisfied;
  - Config renamed Settings, and made the single owner of the server address:
    Setup's duplicate editors (same fields, different save semantics) are now a
    read-only summary with actions;
  - the dashboard offers account creation in place instead of naming a tab, and
    the stale "set the host in the Setup tab" pointers are corrected.

Locks move to parking_lot per project rule (already the convention in
openfut-utas-host and openfut-identity); 47 poisoning unwraps go away.

Verified: 58 tests pass, fmt clean, clippy clean apart from one pre-existing
lint. Driven through the real UI under Xvfb as a fresh install — typed a server,
clicked Create my account, and the config on disk came back with persona
33068179/CAGE claimed from the live host; clicking Save rewrote a stale
`openfut.cfg` from host=10.10.0.99 to host=127.0.0.1.

src/preflight.rs

@@ -92,6 +92,7 @@ pub fn run(cfg: &LauncherConfig) -> Vec<Check> {
         ea_redirect(cfg),
         hostname_mapping(cfg),
         backend_reachable(cfg),
+        hook_config(cfg),
     ]
 }
 
@@ -261,6 +262,50 @@ fn backend_reachable(cfg: &LauncherConfig) -> Check {
     }
 }
 
+/// The deployed `openfut.cfg` is the only server address the *game* can see.
+///
+/// Every panel in this launcher reads the in-memory config, so a settings change
+/// that never reached the file produces the worst possible failure: the UI shows
+/// the new server online while FIFA connects to the old one. Compare the two.
+fn hook_config(cfg: &LauncherConfig) -> Check {
+    const NAME: &str = "Hook server address";
+    let game_dir = cfg.fifa_game_dir.trim();
+    if game_dir.is_empty() {
+        return Check::skip(NAME, "no FIFA game dir configured");
+    }
+    let Some(body) = crate::setup::read_hook_config(std::path::Path::new(game_dir)) else {
+        return Check::skip(
+            NAME,
+            format!("no {} deployed yet", crate::setup::HOOK_CFG_FILE),
+        );
+    };
+    let deployed = match openfut_common::ServerConfig::parse(&body) {
+        Ok(parsed) => parsed,
+        // Unparseable means the hook cannot read it either, and nothing else in
+        // the stack recovers from that — so this one is a genuine failure.
+        Err(e) => {
+            return Check::fail(
+                NAME,
+                format!("{} is unreadable: {e}", crate::setup::HOOK_CFG_FILE),
+            )
+        }
+    };
+    let wanted = cfg.server_config();
+    if deployed == wanted {
+        return Check::pass(NAME, format!("hook redirects to {}", wanted.host));
+    }
+    // Warn, not fail: the launch path rewrites this file before starting the
+    // game, so the drift is real but already covered. Naming both addresses is
+    // what makes it actionable.
+    Check::warn(
+        NAME,
+        format!(
+            "deployed hook still points at {} (settings say {}) — launching rewrites it",
+            deployed.host, wanted.host
+        ),
+    )
+}
+
 fn connects(host: &str, port: u16) -> bool {
     match (host, port).to_socket_addrs() {
         Ok(mut addrs) => addrs.any(|a| TcpStream::connect_timeout(&a, PROBE_TIMEOUT).is_ok()),
@@ -289,12 +334,13 @@ mod tests {
 
     #[test]
     fn an_unconfigured_launcher_skips_rather_than_passes() {
-        // The distinction that matters: a fresh config must not display four
-        // green ticks. "Not checked" is not "checked and fine".
+        // The distinction that matters: a fresh config must not display a column
+        // of green ticks. "Not checked" is not "checked and fine".
         let mut c = cfg();
-        // `default()` points this at a conventional path whose existence varies
-        // by machine. Pin it so the assertion is about the code, not this box.
+        // `default()` points these at conventional paths whose existence varies
+        // by machine. Pin them so the assertion is about the code, not this box.
         c.fifa17_tools_dir = "/nonexistent/openfut-tools".into();
+        c.fifa_game_dir = "/nonexistent/fifa-game-dir".into();
         let checks = run(&c);
         assert!(
             checks.iter().all(|k| k.state == State::Skipped),
@@ -395,4 +441,49 @@ mod tests {
         assert_eq!(check.state, State::Fail, "{}", check.detail);
         assert!(check.detail.contains("no answer on"), "{}", check.detail);
     }
+
+    /// A temp game dir holding one `openfut.cfg` body.
+    fn game_dir_with_cfg(tag: &str, body: &str) -> std::path::PathBuf {
+        let dir =
+            std::env::temp_dir().join(format!("openfut-preflight-{tag}-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        std::fs::write(dir.join(crate::setup::HOOK_CFG_FILE), body).unwrap();
+        dir
+    }
+
+    #[test]
+    fn a_stale_hook_config_is_reported_and_names_both_addresses() {
+        // The silent failure this check exists for: settings changed, the file
+        // the game reads did not.
+        let mut c = cfg();
+        c.openfut_server_host = "10.0.0.2".into();
+        let old = openfut_common::ServerConfig {
+            host: "10.0.0.1".into(),
+            ports: c.server_config().ports,
+        };
+        let dir = game_dir_with_cfg("stale", &old.to_cfg_string());
+        c.fifa_game_dir = dir.to_string_lossy().into_owned();
+        let check = hook_config(&c);
+        assert_eq!(check.state, State::Warn, "{}", check.detail);
+        assert!(check.detail.contains("10.0.0.1"), "{}", check.detail);
+        assert!(check.detail.contains("10.0.0.2"), "{}", check.detail);
+        std::fs::remove_dir_all(dir).ok();
+    }
+
+    #[test]
+    fn a_hook_config_matching_settings_passes() {
+        let mut c = cfg();
+        c.openfut_server_host = "10.0.0.2".into();
+        let dir = game_dir_with_cfg("fresh", &c.server_config().to_cfg_string());
+        c.fifa_game_dir = dir.to_string_lossy().into_owned();
+        assert_eq!(hook_config(&c).state, State::Pass);
+        std::fs::remove_dir_all(dir).ok();
+    }
+
+    #[test]
+    fn a_missing_hook_config_is_skipped_not_passed() {
+        let mut c = cfg();
+        c.fifa_game_dir = "/nonexistent/fifa-game-dir".into();
+        assert_eq!(hook_config(&c).state, State::Skipped);
+    }
 }