feat(chat): limit in-game chat to one message per turn

Enforce one chat message per turn on both ends. The backend rejects a
second message in the same turn (ErrChatAlreadySentThisTurn -> 409
chat_already_sent), keyed on the move-driven turn start (turn_started_at).
The UI derives "already wrote this turn" from the message list against
GameView.lastActivityUnix (no counter, survives reopening, resets on turn
change), hides the field behind a short caption once the limit is reached,
and now reloads the game state on turn/game-state events so the toggle and
the limit follow the live game. Enter is gated on !busy to avoid a
double-send in the in-flight window.

Backend: new game.TurnStartedAt; social GameReader gains it; PostMessage
enforces the limit reusing lastMessageAt. UI: new lib/chatlimit.ts pure
logic + unit tests; Chat/ChatScreen wiring; chat.sentThisTurn and
error.chat_already_sent i18n (en/ru); extended chat e2e. Docs: FUNCTIONAL
(+ru), ARCHITECTURE, UI_DESIGN.

ui/src/game/ChatScreen.svelte

@@ -3,6 +3,7 @@
   import Chat from './Chat.svelte';
   import { gateway } from '../lib/gateway';
   import { app, handleError, clearChatUnread } from '../lib/app.svelte';
+  import { canSendChat, sentThisTurn } from '../lib/chatlimit';
   import type { ChatMessage, StateView } from '../lib/model';
 
   // The Chat tab body, hosted by CommsHub (which supplies the nav bar + tab bar). The
@@ -20,6 +21,11 @@
   const isMyTurn = $derived(
     !!view && (view.game.status === 'active' || view.game.status === 'open') && view.game.toMove === view.seat,
   );
+  // At most one chat message per turn: "already wrote this turn" is derived from the
+  // message list against the move-driven turn start (lastActivityUnix), so it resets when
+  // the turn advances. canSend hides the field once the limit is reached (and always on
+  // the opponent's turn).
+  const canSend = $derived(canSendChat(isMyTurn, view ? sentThisTurn(messages, myId, view.game.lastActivityUnix) : 0));
   // While the auto-match game still has no opponent, chat and nudge are both disabled.
   const waiting = $derived(!!view && view.game.status === 'open');
   const nudgeCooldownSecs = 3600;
@@ -46,22 +52,35 @@
       /* best-effort */
     }
   }
-  onMount(async () => {
+  // loadState (re)reads the game state that drives the chat/nudge toggle and the per-turn
+  // limit. The initial load surfaces an error; live reloads are best-effort.
+  async function loadState(initial = false) {
     try {
       view = await gateway.gameState(id, false);
     } catch (e) {
-      handleError(e);
+      if (initial) handleError(e);
     }
+  }
+  onMount(async () => {
+    await loadState(true);
     await refresh();
   });
 
-  // Live: refresh (and keep the unread cleared) on a chat / nudge for this game.
+  // Live: refresh the message list on a chat / nudge for this game, and reload the state on
+  // a turn / game-state change so the chat/nudge toggle and the per-turn limit (keyed on the
+  // turn start) follow the live game.
   $effect(() => {
     const e = app.lastEvent;
     if (!e) return;
     if ((e.kind === 'chat_message' && e.message.gameId === id) || (e.kind === 'nudge' && e.gameId === id)) {
       void refresh();
     }
+    if (
+      (e.kind === 'your_turn' || e.kind === 'opponent_moved' || e.kind === 'game_over' || e.kind === 'opponent_joined') &&
+      e.gameId === id
+    ) {
+      void loadState();
+    }
   });
   // Re-evaluate the nudge cooldown on a timer so the control re-enables on time.
   $effect(() => {
@@ -91,4 +110,4 @@
   }
 </script>
 
-<Chat {messages} {myId} {busy} myTurn={isMyTurn} {waiting} {nudgeOnCooldown} onsend={sendChat} onnudge={nudge} />
+<Chat {messages} {myId} {busy} myTurn={isMyTurn} {canSend} {waiting} {nudgeOnCooldown} onsend={sendChat} onnudge={nudge} />