ui/phase-16: cargo routes inspector + map pick foundation

Add per-planet cargo routes (COL/CAP/MAT/EMP) to the inspector with
a renderer-driven destination picker (faded out-of-reach planets,
cursor-line anchor, hover-highlight) and per-route arrows on the
map. The pick-mode primitives are exposed via `MapPickService` so
ship-group dispatch in Phase 19/20 can reuse the same surface.

Pass A — generic map foundation:
- hit-test now sizes the click zone to `pointRadiusPx + slopPx` so
  the visible disc is always part of the target.
- `RendererHandle` gains `onPointerMove`, `onHoverChange`,
  `setPickMode`, `getPickState`, `getPrimitiveAlpha`,
  `setExtraPrimitives`, `getPrimitives`. The click dispatcher is
  centralised: pick-mode swallows clicks atomically so the standard
  selection consumers do not race against teardown.
- `MapPickService` (`lib/map-pick.svelte.ts`) wraps the renderer
  contract in a promise-shaped `pick(...)`. The in-game shell
  layout owns the service so sidebar and bottom-sheet inspectors
  see the same instance.
- Debug-surface registry exposes `getMapPrimitives`,
  `getMapPickState`, `getMapCamera` to e2e specs without spawning a
  separate debug page after navigation.

Pass B — cargo-route feature:
- `CargoLoadType`, `setCargoRoute`, `removeCargoRoute` typed
  variants with `(source, loadType)` collapse rule on the order
  draft; round-trip through the FBS encoder/decoder.
- `GameReport` decodes `routes` and the local player's drive tech
  for the inline reach formula (40 × drive). `applyOrderOverlay`
  upserts/drops route entries for valid/submitting/applied
  commands.
- `lib/inspectors/planet/cargo-routes.svelte` renders the
  four-slot section. `Add` / `Edit` call `MapPickService.pick`,
  `Remove` emits `removeCargoRoute`.
- `map/cargo-routes.ts` builds shaft + arrowhead primitives per
  cargo type; the map view pushes them through
  `setExtraPrimitives` so the renderer never re-inits Pixi on
  route mutations (Pixi 8 doesn't support that on a reused
  canvas).

Docs:
- `docs/cargo-routes-ux.md` covers engine semantics + UI map.
- `docs/renderer.md` documents pick mode and the debug surface.
- `docs/calc-bridge.md` records the Phase 16 reach waiver.
- `PLAN.md` rewrites Phase 16 to reflect the foundation + feature
  split and the decisions baked in (map-driven picker, inline
  reach, optimistic overlay via `setExtraPrimitives`).

Tests:
- `tests/map-pick-mode.test.ts` — pure overlay-spec helper.
- `tests/map-cargo-routes.test.ts` — `buildCargoRouteLines`.
- `tests/inspector-planet-cargo-routes.test.ts` — slot rendering,
  picker invocation, collapse, cancel, remove.
- Extensions to `order-draft`, `submit`, `order-load`,
  `order-overlay`, `state-binding`, `inspector-planet`,
  `inspector-overlay`, `game-shell-sidebar`, `game-shell-header`.
- `tests/e2e/cargo-routes.spec.ts` — Playwright happy path: add
  COL, add CAP, remove COL, asserting both the inspector and the
  arrow count via `__galaxyDebug.getMapPrimitives()`.

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

ui/frontend/tests/submit.test.ts

@@ -13,13 +13,17 @@ import {
 	CommandItem,
 	CommandPlanetProduce,
 	CommandPlanetRename,
+	CommandPlanetRouteRemove,
+	CommandPlanetRouteSet,
 	CommandPayload,
 	PlanetProduction,
+	PlanetRouteLoadType,
 	UserGamesOrder,
 	UserGamesOrderResponse,
 } from "../src/proto/galaxy/fbs/order";
 import { submitOrder } from "../src/sync/submit";
 import type {
+	CargoLoadType,
 	OrderCommand,
 	ProductionType,
 } from "../src/sync/order-types";
@@ -214,6 +218,88 @@ describe("submitOrder", () => {
 		expect(inner.subject()).toBe("Scout");
 	});
 
+	test("encodes setCargoRoute as CommandPlanetRouteSet on the wire", async () => {
+		let captured: Uint8Array | null = null;
+		const exec = vi.fn(async (_messageType, payload: Uint8Array) => {
+			captured = payload;
+			return { resultCode: "ok", payloadBytes: new Uint8Array() };
+		});
+		const cmd: OrderCommand = {
+			kind: "setCargoRoute",
+			id: "00000000-0000-0000-0000-00000000aaaa",
+			sourcePlanetNumber: 17,
+			destinationPlanetNumber: 23,
+			loadType: "COL",
+		};
+		await submitOrder(mockClient(exec), GAME_ID, [cmd]);
+		expect(captured).not.toBeNull();
+		const decoded = UserGamesOrder.getRootAsUserGamesOrder(
+			new (await import("flatbuffers")).ByteBuffer(captured!),
+		);
+		const item = decoded.commands(0);
+		expect(item).not.toBeNull();
+		expect(item!.payloadType()).toBe(CommandPayload.CommandPlanetRouteSet);
+		const inner = new CommandPlanetRouteSet();
+		item!.payload(inner);
+		expect(Number(inner.origin())).toBe(17);
+		expect(Number(inner.destination())).toBe(23);
+		expect(inner.loadType()).toBe(PlanetRouteLoadType.COL);
+	});
+
+	test("encodes removeCargoRoute as CommandPlanetRouteRemove on the wire", async () => {
+		let captured: Uint8Array | null = null;
+		const exec = vi.fn(async (_messageType, payload: Uint8Array) => {
+			captured = payload;
+			return { resultCode: "ok", payloadBytes: new Uint8Array() };
+		});
+		const cmd: OrderCommand = {
+			kind: "removeCargoRoute",
+			id: "00000000-0000-0000-0000-00000000bbbb",
+			sourcePlanetNumber: 17,
+			loadType: "MAT",
+		};
+		await submitOrder(mockClient(exec), GAME_ID, [cmd]);
+		const decoded = UserGamesOrder.getRootAsUserGamesOrder(
+			new (await import("flatbuffers")).ByteBuffer(captured!),
+		);
+		const item = decoded.commands(0);
+		expect(item!.payloadType()).toBe(CommandPayload.CommandPlanetRouteRemove);
+		const inner = new CommandPlanetRouteRemove();
+		item!.payload(inner);
+		expect(Number(inner.origin())).toBe(17);
+		expect(inner.loadType()).toBe(PlanetRouteLoadType.MAT);
+	});
+
+	test("maps every cargoLoadType literal to its FBS enum value", async () => {
+		const cases: Array<{ loadType: CargoLoadType; fbs: PlanetRouteLoadType }> = [
+			{ loadType: "COL", fbs: PlanetRouteLoadType.COL },
+			{ loadType: "CAP", fbs: PlanetRouteLoadType.CAP },
+			{ loadType: "MAT", fbs: PlanetRouteLoadType.MAT },
+			{ loadType: "EMP", fbs: PlanetRouteLoadType.EMP },
+		];
+		for (const tc of cases) {
+			let captured: Uint8Array | null = null;
+			const exec = vi.fn(async (_messageType, payload: Uint8Array) => {
+				captured = payload;
+				return { resultCode: "ok", payloadBytes: new Uint8Array() };
+			});
+			const cmd: OrderCommand = {
+				kind: "setCargoRoute",
+				id: `id-${tc.loadType}`,
+				sourcePlanetNumber: 5,
+				destinationPlanetNumber: 6,
+				loadType: tc.loadType,
+			};
+			await submitOrder(mockClient(exec), GAME_ID, [cmd]);
+			const decoded = UserGamesOrder.getRootAsUserGamesOrder(
+				new (await import("flatbuffers")).ByteBuffer(captured!),
+			);
+			const inner = new CommandPlanetRouteSet();
+			decoded.commands(0)!.payload(inner);
+			expect(inner.loadType()).toBe(tc.fbs);
+		}
+	});
+
 	test("maps every productionType literal to its FBS enum value", async () => {
 		const cases: Array<{
 			productionType: ProductionType;