R4: push enrichment — events carry a state delta, kill the last poll

Enrich the in-app live stream into a delta channel so the UI renders a move from the event without a follow-up game.state, and make the matchmaking poll a stream-down fallback.

- pkg/fbs: trailing fields on opponent_moved (move+game+bag_len), your_turn (move_count), match_found (state), game_over (game), notify (account/invitation/state), MoveResult (rack+bag_len); regenerate Go + TS.
- backend: notify owns the FB encoding (encode.go + payload.go input structs); game/lobby/social map their domain types in. emitMove builds the move delta; game.Service.InitialState feeds match_found/game_started the recipient's initial StateView; friends/invitations notify carry their account/invitation. The move-commit response (submit_play/pass/exchange/resign) returns the actor's refilled rack + bag size.
- gateway: MoveResult transcode carries rack+bag_len.
- ui: pure lib/gamedelta.ts reducer advances the per-game cache keyed on move_count (idempotent + gap-safe); app.svelte seeds the cache on match_found/game_started; Game.svelte applies the delta (commit/pass/exchange/resign drop their load()); NewGame polls only while app.streamAlive is false.
- docs: ARCHITECTURE §10, FUNCTIONAL(+ru), backend/gateway/ui READMEs; PRERELEASE R4 marked done + Refinements.

docs/ARCHITECTURE.md

@@ -510,11 +510,22 @@ seat from the same game commit when a game finishes — any path: a closing play
 resign or timeout) and **enriched your-turn** so the out-of-app push reads in full: it now
 also carries the mover's display name, their last action and the main word of a scoring play,
 and a **recipient-first** running score line (e.g. `120:95:80`, the reader's score first).
-Event payloads are FlatBuffers-encoded by
-the backend and forwarded verbatim. A client that is not currently streaming falls
-back to the matchmaker's `Poll` for match-found and, for the lobby **notification
-badge** (incoming friend requests + open invitations), the client polls on lobby
-open and on focus as well as re-polling on the `notify` event — covering a push
+**R4 enriched the in-app stream into a delta channel** so the client renders from the event
+without a follow-up `game.state`: **opponent-moved** carries the committed move plus the post-move
+summary (per-seat scores, whose turn, move count, status) and the bag size, which the client
+applies to its per-game cache keyed on the **move count** — idempotent (a re-delivered or own-move
+echo is a no-op) and gap-safe (a missed move falls back to a `game.state` + `game.history`
+refetch); **your-turn** carries that move count as a consistency check; **match-found** and the
+**game-started** notify carry the recipient's full **initial `StateView`**, so opening a freshly
+started game is instant; **game-over** carries the final summary; the lobby **notify** sub-kinds
+carry the changed account / invitation. The move-commit **response** (`submit_play` / `pass` /
+`exchange` / `resign`) likewise returns the actor's own refilled rack and bag size, so the mover
+renders the next turn without a self-refetch. The `notify` package owns the FlatBuffers encoding
+(fed wire-agnostic input structs by the domain services) and the gateway forwards every payload
+verbatim. A client that is not currently streaming falls back to the matchmaker's `Poll` for
+match-found — the client polls **only while the stream is down**, since a live stream delivers
+match-found itself; for the lobby **notification badge** (incoming friend requests + open
+invitations) the client re-polls on the `notify` event and on lobby open / focus, covering a push
 missed while the app was hidden. **Out-of-app platform push** (Stage 9) is a fallback
 the **gateway** routes from the same firehose: for an event whose recipient has **no
 live in-app stream** it resolves the backend `/internal/push-target` (their Telegram