fix(offline): zero tile weights on cold boot + wrong-mode game in the lobby

Two pre-existing offline bugs, both exposed once offline mode became usable (cold boot +
toggling), owner-reported on the contour.

Bug 1 -- offline tiles render weight 0. The rack/board read tile values from the
lib/alphabet cache, populated only by the online wire codec (server-sent alphabet) or the
mock (so the e2e masked it). A local game never goes through the codec, so on a cold
offline boot with no prior online session the cache was empty and every value read 0
(scores stayed correct -- they come from the offline ruleset). Fix: the local source
seeds lib/alphabet from the static offline ruleset (letters + values) when it builds a
game view.

Bug 2 -- the lobby showed (and could open) the other mode's game after a toggle. Two
causes: (a) the lobby cache was not mode-tagged, so getLobby() instant-rendered the last
snapshot regardless of mode; (b) load() wrote the module list after an await with no
generation guard, so a slow online gamesList() finishing after a fast offline list() (or
vice versa) left the wrong mode's games on screen. Fix: tag the snapshot with offline and
gate getLobby() on it; add a load-sequence guard so only the latest load() writes.

- localgame/source.ts: ensureAlphabet from the ruleset in gameView (+ unit test).
- lobbycache.ts: LobbySnapshot.offline + getLobby(offline) mode check (+ tests).
- Lobby.svelte: setLobby tags the mode; load() carries a generation guard.

check 0 / unit 485 / e2e 198 / app entry 113.8/114.

ui/src/lib/localgame/source.ts

@@ -13,6 +13,7 @@ import { serializeGame, replayGame, type LocalGameRecord, type Seat as LocalSeat
 import { getLocalGame, saveLocalGame, listLocalGames, deleteLocalGame } from './store';
 import { RULESETS } from './ruleset';
 import { getDawg } from '../dict';
+import { setAlphabet, hasAlphabet } from '../alphabet';
 import { LOCAL_ID_PREFIX, isLocalGameId } from './id';
 import { decide } from '../robot/strategy';
 import { GatewayError, type PlacedTile } from '../client';
@@ -345,8 +346,22 @@ export class LocalSource implements GameLoopSource {
     return { game: this.gameView(entry), seat, rack, bagLen: entry.game.bagLength, hintsRemaining: 1, walletBalance: 0 };
   }
 
+  // Offline there is no server to send the per-variant alphabet table (letters + tile values) the
+  // rack and board render from (lib/alphabet); seed it from the static offline ruleset so a cold-
+  // booted local game shows real tile weights instead of zeros. Idempotent and cheap — a no-op once
+  // the table is cached (from here or a prior online session).
+  private ensureAlphabet(variant: Variant): void {
+    if (hasAlphabet(variant)) return;
+    const rs = RULESETS[variant];
+    setAlphabet(
+      variant,
+      rs.letters.map((letter, index) => ({ index, letter, value: rs.values[index] })),
+    );
+  }
+
   private gameView(entry: Live): GameView {
     const { game, record } = entry;
+    this.ensureAlphabet(record.variant);
     const seats: Seat[] = record.seats.map((s, i) => ({
       seat: i,
       accountId: s.accountId ?? `${LOCAL_ID_PREFIX}${s.kind}:${i}`,