feat(social): asymmetric per-user block, in-game block control, admin lists

Make a per-user block one-directional and non-destructive: the blocker stops
receiving everything from the blocked user (chat, nudge, friend requests,
invitations) and the matchmaker never pairs them, while the blocked user
notices nothing — their sends still persist by the normal rules but are never
delivered or surfaced (born-read). A block no longer deletes the friendship
(an unblock cleanly restores it) and instant-reads any unread the blocked user
had left for the blocker.

- backend: a directional blockExists guard across chat/nudge/friends/invitations
  (store-but-hide for the blocked->blocker direction, refuse blocker->blocked);
  the matchmaker excludes a block-related pair (both directions) from auto-match;
  user_blocked/user_unblocked notifications to the blocker only (in-app only).
- ui: the opponent score card gains a block ✖️ control mirroring add-friend
  (red "Block?" confirm, mutual-hide while confirming, struck name, hidden chat
  composer when blocked); optimistic apply + event confirm + rollback for both.
- admin: the user card gains cross-linked blocks / blocked-by / friends lists.
- docs: FUNCTIONAL(+ru), ARCHITECTURE §10 + decision record, UI_DESIGN, PRERELEASE.

ui/src/game/ChatScreen.svelte

@@ -16,6 +16,9 @@
   let messages = $state<ChatMessage[]>([]);
   let busy = $state(false);
   let tick = $state(0);
+  // The opponents the viewer has blocked: when every opponent is blocked the composer is hidden
+  // (only the chat log remains), matching the backend guard that rejects messaging a blocked peer.
+  let blockedIds = $state(new Set<string>());
 
   const myId = $derived(app.session?.userId ?? '');
   const isMyTurn = $derived(
@@ -31,6 +34,14 @@
   const canNudge = $derived(!!view && view.game.status === 'active' && view.game.toMove !== view.seat);
   // While the auto-match game still has no opponent, chat and nudge are both disabled.
   const waiting = $derived(!!view && view.game.status === 'open');
+  // peerBlocked is true when every seated opponent is one the viewer has blocked: the whole
+  // composer is then hidden (a blocked opponent cannot be messaged).
+  const peerBlocked = $derived.by(() => {
+    const v = view;
+    if (!v) return false;
+    const opponents = v.game.seats.filter((s) => s.seat !== v.seat && !!s.accountId);
+    return opponents.length > 0 && opponents.every((s) => blockedIds.has(s.accountId));
+  });
   const nudgeCooldownSecs = 3600;
   // The nudge is one-per-hour-per-game and clears once the player chats (engagement); the
   // backend stays authoritative, so a move-based reset is left to it.
@@ -64,9 +75,20 @@
       if (initial) handleError(e);
     }
   }
+  // loadBlocked refreshes the viewer's blocked set (best-effort); guests have none.
+  async function loadBlocked() {
+    if (app.profile?.isGuest) return;
+    try {
+      const bl = await gateway.blocksList();
+      blockedIds = new Set(bl.map((b) => b.accountId));
+    } catch {
+      /* best-effort */
+    }
+  }
   onMount(async () => {
     await loadState(true);
     await refresh();
+    void loadBlocked();
   });
 
   // Live: refresh the message list on a chat / nudge for this game, and reload the state on
@@ -84,6 +106,10 @@
     ) {
       void loadState();
     }
+    // A block/unblock applied: re-derive whether the composer should be hidden.
+    if (e.kind === 'notify' && (e.sub === 'user_blocked' || e.sub === 'user_unblocked')) {
+      void loadBlocked();
+    }
   });
   // Re-evaluate the nudge cooldown on a timer so the control re-enables on time.
   $effect(() => {
@@ -123,6 +149,7 @@
   {waiting}
   {nudgeOnCooldown}
   vsAi={!!view && view.game.vsAi}
+  blocked={peerBlocked}
   onsend={sendChat}
   onnudge={nudge}
 />