games: the poker table others can walk up to, and the one that empties when they leave

Phase C's handler cutover: hold'em now runs on the shared-table runtime instead
of the solo game_live_hands blob. Solo is just a table nobody else has joined.

- holdem implements tableGame (name/timeout/stacks). timeout auto-checks-or-folds
  a walked-away seat and marks it away; the audit is per-hand, with each pot's
  rake on the winner's row alone so HouseTake cannot 4x itself.
- New endpoints: sit opens a table (or joins an open bot seat), leave gets you up
  (LeaveTable + CloseTable behind the last human), plus tables (lobby), stream
  (SSE), chat and say. The move path loads the player's table, applies at their
  seat, commits under the version guard, and fans an SSE nudge.
- Engine grows Vacate/Occupy (a human leaving/joining between hands) and
  TableSeats (a named human + bots). The view carries your_seat, since a shared
  table has no seat-zero-is-you convention.
- Storage grows OpenSoloTable (stake+claim+create+seat in one tx), PlayerSeat,
  and the abandoned-table reaper (AbandonedTables/ReapTable) — the seated-player
  counterpart to the session reaper, since a walked-away stack is inside a blob
  the session reaper cannot see. upsertSeat preserves last_seen so an auto-fold
  never refreshes an away player's clock.

Not deployed, and the felt is not rewired yet: the frontend still assumes
seat zero is you, so this is browser-unverified. Solo sit/deal/play/leave and
two-human join/leave/reaper are covered by tests; the whole suite is green.

Claude-Session: https://claude.ai/code/session_013M5nD7PgUboJXoDcYHzpuJ

internal/web/games_clock.go

@@ -67,6 +67,7 @@ func (s *Server) StartTableClock(ctx context.Context) {
 	}
 	go s.runTableClock(ctx)
 	go s.runSessionReaper(ctx)
+	go s.runTableReaper(ctx)
 }
 
 func (s *Server) runTableClock(ctx context.Context) {
@@ -131,6 +132,9 @@ func (s *Server) runClockTable(ref storage.TableRef) {
 		}
 
 		st, newSeats, err := game.timeout(t.State, seats)
+		if errors.Is(err, errNotDue) {
+			return nil // the race resolved without us; nothing to act on
+		}
 		if err != nil {
 			slog.Error("games: clock timeout", "table", t.ID, "err", err)
 			return nil
@@ -174,7 +178,9 @@ func (s *Server) publishTable(tableID string) {
 	}
 	// The frame is just a nudge carrying the version: a subscriber that sees a gap
 	// refetches the authoritative, per-seat table. So the payload can be minimal.
-	data, _ := json.Marshal(map[string]any{"version": t.Version, "phase": t.Phase})
+	// The type tells the browser a table changed (come and look) from a chat line
+	// (render it in place) — both ride the one stream.
+	data, _ := json.Marshal(map[string]any{"type": "table", "version": t.Version, "phase": t.Phase})
 	s.hub.publish(tableID, hubFrame{Version: t.Version, Data: data})
 }