Add hand-end scoring summary screen with acknowledgement

After each hand of an unfinished match the game now pauses in a new
hand_end phase instead of dealing immediately:

- engine: hand_points gains an 'award' map (which team won each category),
  _end_hand stops at hand_end with a deadline, new acknowledge_hand deals
  the next hand once all four players have acked; plays are rejected while
  the summary is up
- state: acked seats, hand_end_deadline and hand_ack_timeout are persisted
  and exposed in the personalized view (also on the finished state, so the
  final hand is explained before the result)
- ws: new {"action": "ack"}; a per-hand timer force-deals the next hand
  after HAND_ACK_TIMEOUT_SECONDS (new env var, default 30s) so an away
  player cannot stall the match
- web: modal explaining each category in plain language with icons (card
  images for denara/settebello/primiera), team-coloured rows, running
  totals with progress bars, an 'Understood — next hand' button that turns
  into 'Waiting for …' plus an auto-continue countdown; the final screen
  shows the last hand's breakdown too

Verified in the browser against the compose stack: hand played to
completion, summary rendered (including a carte tie), ack from all four
players dealt the next hand live, and the auto-continue path fired when
nobody acked. 60 backend tests + mypy + cargo tests green.

server/src/scopa/ws.py

@@ -16,11 +16,14 @@ Client -> server messages are JSON objects::
 
     {"action": "play", "card": "07D", "capture": ["02D", "05C"]}
     {"action": "play", "card": "07D"}
+    {"action": "ack"}
     {"action": "state"}
 
 ``capture`` lists the table cards to take and must be a legal capture when
 one exists (see :func:`scopa.game.engine.legal_captures`); it is omitted
-when the played card cannot capture.
+when the played card cannot capture. ``ack`` acknowledges the hand-end
+scoring summary; the next hand is dealt when all four players have
+acknowledged or the timeout fires.
 
 Mutations run under the per-game lock; after a successful move the new
 state is saved to Redis and a change signal is published. Every connected
@@ -40,7 +43,7 @@ from . import auth
 from .app import app, game_store
 from .game import engine
 from .game.errors import GameError
-from .game.state import PHASE_FINISHED, GameState
+from .game.state import PHASE_FINISHED, PHASE_HAND_END, GameState
 from .stats import save_match_result
 
 Send = Callable[[Dict[str, Any]], Awaitable[None]]
@@ -132,6 +135,8 @@ async def _handle_message(send: Send, game_id: str, sub: str, raw: str) -> None:
     action = data.get("action")
     if action == "play":
         await _handle_play(send, game_id, sub, data)
+    elif action == "ack":
+        await _handle_ack(send, game_id, sub)
     elif action in ("state", "sync"):
         state = await game_store.load(game_id)
         if state is not None:
@@ -140,6 +145,56 @@ async def _handle_message(send: Send, game_id: str, sub: str, raw: str) -> None:
         await send(_error(f"unknown action: {action!r}"))
 
 
+# --- hand-end acknowledgement ------------------------------------------------
+
+# Running auto-continue timers, keyed by (game_id, hand_number), so a hand's
+# timeout is scheduled only once even when several clients are connected.
+_hand_end_timers: Dict[tuple, asyncio.Task] = {}
+
+
+async def _handle_ack(send: Send, game_id: str, sub: str) -> None:
+    async with game_store.lock(game_id):
+        state = await game_store.load(game_id)
+        if state is None:
+            await send(_error("game not found", code="not_found"))
+            return
+        try:
+            engine.acknowledge_hand(state, sub)
+        except GameError as exc:
+            await send(_error(str(exc), code="illegal_move"))
+            return
+        await game_store.save(state)
+        await game_store.publish(game_id)
+
+
+def schedule_hand_end_timer(game_id: str, hand_number: int, timeout: int) -> None:
+    """Deal the next hand after the acknowledgement timeout, even if not
+    everyone has clicked. Fizzles if the hand already advanced."""
+    key = (game_id, hand_number)
+    if key in _hand_end_timers:
+        return
+
+    async def _auto_advance() -> None:
+        try:
+            await asyncio.sleep(timeout)
+            async with game_store.lock(game_id):
+                state = await game_store.load(game_id)
+                if (
+                    state is None
+                    or state.phase != engine.PHASE_HAND_END
+                    or state.hand_number != hand_number
+                ):
+                    return
+                for player in state.players:
+                    engine.acknowledge_hand(state, player.sub)
+                await game_store.save(state)
+                await game_store.publish(game_id)
+        finally:
+            _hand_end_timers.pop(key, None)
+
+    _hand_end_timers[key] = asyncio.create_task(_auto_advance())
+
+
 async def _handle_play(
     send: Send, game_id: str, sub: str, data: Dict[str, Any]
 ) -> None:
@@ -171,5 +226,7 @@ async def _handle_play(
 
         if state.phase == PHASE_FINISHED:
             await save_match_result(state)
+        elif state.phase == PHASE_HAND_END:
+            schedule_hand_end_timer(game_id, state.hand_number, state.hand_ack_timeout)
         await game_store.save(state)
         await game_store.publish(game_id)