feat: on-device move preview (local eval) with network fallback

Score and validate a tentative move on-device instead of a per-arrangement network
round trip. The dawg reader and the validate/score/direction slice of the
scrabble-solver engine are ported to TypeScript (ui/src/lib/dict), pinned
byte-for-byte to the Go engine by a `conformance` CI job (full-dictionary reader
parity plus a battery of plays across every variant and both cross-word rules,
including the inferred orientation). The server stays authoritative — submit_play
re-validates — so the local result is an advisory accelerator only.

- backend: Registry.DictBytes + an authed GET /api/v1/user/dict/{variant}/{version}
  (immutable) streaming the pinned per-game dawg; caddy routes /dict to the gateway.
- gateway: a session-gated /dict edge route proxying it; fetchDict on the transport.
- client: the dictionary loads on game open (low priority so it never starves the
  game on a slow link; aborted at a 5s cap or when leaving the game), is cached in
  IndexedDB (best-effort, self-healing on a rejected blob) and reused across
  sessions; a warm-up overlay covers a cold load, then the network preview is the
  fallback; a bad-connection breaker stops warming after repeated misses; the move
  preview cancels its in-flight request when the tiles change.
- parity generators backend/cmd/{dictgen,validategen} + gated Vitest suites, run in
  CI against the release dictionaries. A hidden debug readout lists the cached
  dictionaries + breaker state, and its reset clears the cache.
- docs: ARCHITECTURE §5, TESTING, UI_DESIGN, FUNCTIONAL (+ru).

ui/src/lib/transport.ts

@@ -36,12 +36,13 @@ export function createTransport(baseUrl: string): GatewayClient {
   // exec runs one unary op, auto-retrying transient transport failures with capped backoff (so a
   // dropped connection or a rate-limit recovers seamlessly) and driving the global Connecting
   // indicator. A successful round-trip marks the gateway reachable; a domain result_code is final.
-  async function exec(messageType: string, payload: Uint8Array): Promise<Uint8Array> {
+  async function exec(messageType: string, payload: Uint8Array, signal?: AbortSignal): Promise<Uint8Array> {
     for (let attempt = 0; ; attempt++) {
       let res;
       try {
-        res = await client.execute({ messageType, payload, requestId: '' }, { headers: headers() });
+        res = await client.execute({ messageType, payload, requestId: '' }, { headers: headers(), signal });
       } catch (e) {
+        if (signal?.aborted) throw e; // an intentional cancel (e.g. the tiles moved) — do not retry
         const err = toGatewayError(e);
         if (retryable(err.code, messageType) && attempt < MAX_RETRIES) {
           reportOffline();
@@ -62,6 +63,23 @@ export function createTransport(baseUrl: string): GatewayClient {
       token = t;
     },
 
+    async fetchDict(variant, version, opts) {
+      if (!token) throw new Error('fetchDict: no session');
+      // Low priority so the browser schedules the (large) dictionary behind the game's own
+      // requests — the move eval, state and live events — on a slow link (EDGE). Ignored
+      // where the Priority Hints API is unsupported (iOS WebKit), which is harmless. The
+      // signal aborts a stalled download so it stops holding the channel; reload (the debug
+      // "clear") bypasses the browser HTTP cache to force a fresh copy.
+      const res = await fetch(`${origin}/dict/${encodeURIComponent(variant)}/${encodeURIComponent(version)}`, {
+        headers: { authorization: `Bearer ${token}` },
+        priority: 'low',
+        signal: opts?.signal,
+        cache: opts?.reload ? 'reload' : undefined,
+      } as RequestInit);
+      if (!res.ok) throw new Error(`fetchDict ${variant}/${version}: HTTP ${res.status}`);
+      return res.arrayBuffer();
+    },
+
     async authTelegram(initData) {
       return codec.decodeSession(await exec('auth.telegram', codec.encodeTelegramLogin(initData, browserOffset())));
     },
@@ -119,8 +137,8 @@ export function createTransport(baseUrl: string): GatewayClient {
     async hint(id) {
       return codec.decodeHintResult(await exec('game.hint', codec.encodeGameAction(id)));
     },
-    async evaluate(id, tiles, variant) {
-      return codec.decodeEvalResult(await exec('game.evaluate', codec.encodeEval(id, tiles, variant)));
+    async evaluate(id, tiles, variant, signal) {
+      return codec.decodeEvalResult(await exec('game.evaluate', codec.encodeEval(id, tiles, variant), signal));
     },
     async checkWord(id, word, variant) {
       return codec.decodeWordCheck(await exec('game.check_word', codec.encodeCheckWord(id, word, variant)));