ui/phase-11: map wired to live game state

Replaces the Phase 10 map stub with live planet rendering driven by
`user.games.report`, and wires the header turn counter to the same
data. Phase 11's frontend sits on a per-game `GameStateStore` that
lives in `lib/game-state.svelte.ts`: the in-game shell layout
instantiates one per game, exposes it through Svelte context, and
disposes it on remount. The store discovers the game's current turn
through `lobby.my.games.list`, fetches the matching report, and
exposes a TS-friendly snapshot to the header turn counter, the map
view, and the inspector / order / calculator tabs that later phases
will plug onto the same instance.

The pipeline forced one cross-stage decision: the user surface needs
the current turn number to know which report to fetch, but
`GameSummary` did not expose it. Phase 11 extends the lobby
catalogue (FB schema, transcoder, Go model, backend
gameSummaryWire, gateway decoders, openapi, TS bindings,
api/lobby.ts) with `current_turn:int32`. The data was already
tracked in backend's `RuntimeSnapshot.CurrentTurn`; surfacing it is
a wire change only. Two alternatives were rejected: a brand-new
`user.games.state` message (full wire-flow for one field) and
hard-coding `turn=0` (works for the dev sandbox, which never
advances past zero, but renders the initial state for any real
game). The change crosses Phase 8's already-shipped catalogue per
the project's "decisions baked back into the live plan" rule —
existing tests and fixtures are updated in the same patch.

The state binding lives in `map/state-binding.ts::reportToWorld`:
one Point primitive per planet across all four kinds (local /
other / uninhabited / unidentified) with distinct fill colours,
fill alphas, and point radii so the user can tell them apart at a
glance. The planet engine number is reused as the primitive id so
a hit-test result resolves directly to a planet without an extra
lookup table. Zero-planet reports yield a well-formed empty world;
malformed dimensions fall back to 1×1 so a bad report cannot crash
the renderer.

The map view's mount effect creates the renderer once and skips
re-mount on no-op refreshes (same turn, same wrap mode); a turn
change or wrap-mode flip disposes and recreates it. The renderer's
external API does not yet expose `setWorld`; Phase 24 / 34 will
extract it once high-frequency updates land. The store installs a
`visibilitychange` listener that calls `refresh()` when the tab
regains focus.

Wrap-mode preference uses `Cache` namespace `game-prefs`, key
`<gameId>/wrap-mode`, default `torus`. Phase 11 reads through
`store.wrapMode`; Phase 29 wires the toggle UI on top of
`setWrapMode`.

Tests: Vitest unit coverage for `reportToWorld` (every kind,
ids, styling, empty / zero-dimension edges, priority order) and
for the store lifecycle (init success, missing-membership error,
forbidden-result error, `setTurn`, wrap-mode persistence across
instances, `failBootstrap`). Playwright e2e mocks the gateway for
`lobby.my.games.list` and `user.games.report` and asserts the
live data path: turn counter shows the reported turn,
`active-view-map` flips to `data-status="ready"`, and
`data-planet-count` matches the fixture count. The zero-planet
regression and the missing-membership error path are covered.

Phase 11 status stays `pending` in `ui/PLAN.md` until the local-ci
run lands green; flipping to `done` follows in the next commit per
the per-stage CI gate in `CLAUDE.md`.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

ui/frontend/src/routes/games/[id]/+layout.svelte

@@ -12,11 +12,20 @@ layout owns:
   header view-menu naturally drops the overlay even if `mobileTool`
   was set on a previous tap.
 
+Phase 11 adds the per-game `GameStateStore` instance owned by this
+layout: it constructs the `GalaxyClient`, fetches the matching lobby
+record to discover `current_turn`, then loads the report. The store
+is shared with descendants via `setContext("gameState", ...)` so the
+header turn counter, the map view, and later inspector tabs all read
+from the same snapshot.
+
 State preservation across active-view switches works for free
 because SvelteKit keeps this layout instance mounted while children
-swap.
+swap; navigating between games unmounts and remounts the layout, so
+the next game's snapshot is loaded fresh.
 -->
 <script lang="ts">
+	import { onDestroy, onMount, setContext } from "svelte";
 	import { page } from "$app/state";
 	import Header from "$lib/header/header.svelte";
 	import Sidebar from "$lib/sidebar/sidebar.svelte";
@@ -24,6 +33,13 @@ swap.
 	import Calculator from "$lib/sidebar/calculator-tab.svelte";
 	import Order from "$lib/sidebar/order-tab.svelte";
 	import type { MobileTool } from "$lib/sidebar/types";
+	import { GameStateStore, GAME_STATE_CONTEXT_KEY } from "$lib/game-state.svelte";
+	import { session } from "$lib/session-store.svelte";
+	import { loadStore } from "../../../platform/store/index";
+	import { loadCore } from "../../../platform/core/index";
+	import { createEdgeGatewayClient } from "../../../api/connect";
+	import { GalaxyClient } from "../../../api/galaxy-client";
+	import { GATEWAY_BASE_URL, GATEWAY_RESPONSE_PUBLIC_KEY } from "$lib/env";
 
 	let { children } = $props();
 
@@ -36,9 +52,54 @@ swap.
 		isOnMap ? mobileTool : "map",
 	);
 
+	const gameState = new GameStateStore();
+	setContext(GAME_STATE_CONTEXT_KEY, gameState);
+
 	function toggleSidebar(): void {
 		sidebarOpen = !sidebarOpen;
 	}
+
+	async function sha256(payload: Uint8Array): Promise<Uint8Array> {
+		const digest = await crypto.subtle.digest("SHA-256", payload as BufferSource);
+		return new Uint8Array(digest);
+	}
+
+	onMount(() => {
+		(async (): Promise<void> => {
+			if (
+				session.keypair === null ||
+				session.deviceSessionId === null ||
+				GATEWAY_RESPONSE_PUBLIC_KEY.length === 0
+			) {
+				return;
+			}
+			const keypair = session.keypair;
+			const deviceSessionId = session.deviceSessionId;
+			try {
+				const [{ cache }, core] = await Promise.all([loadStore(), loadCore()]);
+				const client = new GalaxyClient({
+					core,
+					edge: createEdgeGatewayClient(GATEWAY_BASE_URL),
+					signer: (canonical) => keypair.sign(canonical),
+					sha256,
+					deviceSessionId,
+					gatewayResponsePublicKey: GATEWAY_RESPONSE_PUBLIC_KEY,
+				});
+				await gameState.init({ client, cache, gameId });
+			} catch (err) {
+				gameState.failBootstrap(describeBootstrapError(err));
+			}
+		})();
+	});
+
+	onDestroy(() => {
+		gameState.dispose();
+	});
+
+	function describeBootstrapError(err: unknown): string {
+		if (err instanceof Error) return err.message;
+		return "request failed";
+	}
 </script>
 
 <div class="game-shell" data-testid="game-shell">