feat(lobby): keep lobby/game caches fresh from any screen + invitation delta channel

Builds on the cross-screen cache work: the global stream handler now keeps both
caches current no matter which screen is mounted, and invitations become a live
delta channel so the lobby's invitations list is fresh from any screen too.

Client (boundary already started):
- advanceCached now also folds opponent_joined into a not-currently-viewed game's
  cache via a new pure reducer applyOpponentJoined (extracted and reused by the
  mounted game board), so opening an open game that filled while you were elsewhere
  is flash-free.
- patchLobbyInvitation upserts a still-pending invitation and removes a terminal
  one (started/declined/cancelled/expired); the global notify handler calls it on
  the invitation / invitation_update sub-kinds.

Invitations delta channel (no wire/gateway/connector change — the notification
already carries the full invitation with id/status/game_id end to end):
- notify: a new in-app-only NotifyInvitationUpdate sub + NotificationInvitationUpdate
  constructor (shares encoding with NotificationInvitation). The Telegram connector
  renders no message for it, so a decline/cancel never becomes an out-of-app push.
- lobby: emit the changed invitation to every participant on respond (accept/decline),
  on the final accept's game start, and on cancel — so each participant's lobby patches
  its list in place. The authoritative list holds only pending invitations, so the
  client's pending-vs-terminal rule matches it exactly.

Tests: applyOpponentJoined + patchLobbyInvitation unit tests (TDD), the
NotificationInvitationUpdate encoding unit test, and integration assertions that
decline/cancel/accept publish invitation_update to every participant. Full local
suite green (backend unit+integration, UI check/unit/build/bundle/e2e). Docs:
ARCHITECTURE §10 (notify catalog + in-app-only note) and UI_DESIGN updated.

ui/src/lib/lobbycache.test.ts

@@ -1,6 +1,23 @@
 import { beforeEach, describe, expect, it } from 'vitest';
-import { clearLobby, getLobby, patchLobbyGame, setLobby } from './lobbycache';
-import type { AccountRef, GameView } from './model';
+import { clearLobby, getLobby, patchLobbyGame, patchLobbyInvitation, setLobby } from './lobbycache';
+import type { AccountRef, GameView, Invitation } from './model';
+
+function invitation(id: string, status: string): Invitation {
+  return {
+    id,
+    inviter: { accountId: 'inv', displayName: 'Inv' },
+    invitees: [],
+    variant: 'scrabble_en',
+    turnTimeoutSecs: 300,
+    hintsAllowed: true,
+    hintsPerPlayer: 0,
+    multipleWordsPerTurn: true,
+    dropoutTiles: 'remove',
+    status,
+    gameId: '',
+    expiresAtUnix: 0,
+  };
+}
 
 function gameView(id: string, status: GameView['status'] = 'active', toMove = 0): GameView {
   return {
@@ -59,3 +76,46 @@ describe('patchLobbyGame', () => {
     expect(games[0].toMove).toBe(0); // the original array/object is left intact
   });
 });
+
+describe('patchLobbyInvitation', () => {
+  it('adds a new pending invitation to the cached lobby', () => {
+    setLobby({ games: [], invitations: [], incoming: [] });
+    patchLobbyInvitation(invitation('i1', 'pending'));
+    expect(getLobby()?.invitations.map((x) => x.id)).toEqual(['i1']);
+  });
+
+  it('replaces a pending invitation already in the list (e.g. an updated response)', () => {
+    setLobby({ games: [], invitations: [invitation('i1', 'pending'), invitation('i2', 'pending')], incoming: [] });
+    const updated = { ...invitation('i1', 'pending'), turnTimeoutSecs: 999 };
+    patchLobbyInvitation(updated);
+    expect(getLobby()?.invitations.map((x) => x.id)).toEqual(['i1', 'i2']);
+    expect(getLobby()?.invitations.find((x) => x.id === 'i1')?.turnTimeoutSecs).toBe(999);
+  });
+
+  it('removes an invitation that reached a terminal status', () => {
+    for (const terminal of ['declined', 'cancelled', 'started', 'expired']) {
+      setLobby({ games: [], invitations: [invitation('i1', 'pending'), invitation('i2', 'pending')], incoming: [] });
+      patchLobbyInvitation(invitation('i1', terminal));
+      expect(getLobby()?.invitations.map((x) => x.id)).toEqual(['i2']);
+    }
+  });
+
+  it('is a no-op for a terminal invitation that is not in the list', () => {
+    setLobby({ games: [], invitations: [invitation('i2', 'pending')], incoming: [] });
+    patchLobbyInvitation(invitation('i1', 'declined'));
+    expect(getLobby()?.invitations.map((x) => x.id)).toEqual(['i2']);
+  });
+
+  it('is a no-op when there is no cached lobby yet', () => {
+    patchLobbyInvitation(invitation('i1', 'pending'));
+    expect(getLobby()).toBeNull();
+  });
+
+  it('preserves games and incoming when patching an invitation', () => {
+    const incoming: AccountRef[] = [{ accountId: 'u9', displayName: 'Nine' }];
+    setLobby({ games: [gameView('g1')], invitations: [], incoming });
+    patchLobbyInvitation(invitation('i1', 'pending'));
+    expect(getLobby()?.games.map((g) => g.id)).toEqual(['g1']);
+    expect(getLobby()?.incoming).toEqual(incoming);
+  });
+});