feat(database): store gameplay replays in compact form

- Add compact storage package: codec, records, hydrate, replay blobs, cache.
- Running games write game_turns and snake_states keyed by integer ids.
- Encode moves as 1-byte codes and bodies as head plus step codes.
- Store food and hazards only when they changed since the previous turn.
- Strip reasoning fields that duplicate stored values and restore on read.
- Pack finished games into one zstd blob per game in game_replays.
- Merge late turns into packed blobs during the stale-game sweep.
- Extract SQLite and PostgreSQL schemas into dedicated modules.
- Add read/import game bundle and list_game_ids to the backend template.
- Add legacy readers and converter for the old turns/snake_turns layout.
- Add migrate_gameplay_to_compact.py with in-place or cross-DB migration.
- Verify every migrated game and keep legacy rows on failure.
- Support --since, --minimum-quality and guarded --drop-legacy.
- Add just recipe migrate-gameplay-postgres.
- Rewrite merge script to copy game by game via backend bundles.
- Move benchmark state loading into benchmark_states for both backends.
- Update PostgreSQL cleanup script to the new replay tables.
- Drop sqlite-zstd build stages from the Dockerfile.
- Remove old migration scripts, normalized_turn and their tests.
- Add tests for compact storage, schema, legacy migration and PostgreSQL.
- Document the compact layout and migration workflow in the README.

scripts/cleanup_postgresql_gameplay.py

@@ -21,20 +21,20 @@ async def cleanup(dsn: str, older_than_days: int, dry_run: bool, vacuum: bool) -
         AND COALESCE(ended_at, started_at) < $1
     """, cutoff))
     rows = await connection.fetchrow("""
+      WITH candidates AS (
+        SELECT game_id, gid FROM games
+        WHERE has_replay
+          AND quality_status = 'low_quality'
+          AND COALESCE(ended_at, started_at) < $1
+      )
       SELECT
-        (SELECT count(*) FROM turns t JOIN games g USING (game_id)
-          WHERE g.has_replay AND g.quality_status = 'low_quality'
-            AND COALESCE(g.ended_at, g.started_at) < $1) AS turns,
-        (SELECT count(*) FROM snake_turns t JOIN games g USING (game_id)
-          WHERE g.has_replay AND g.quality_status = 'low_quality'
-            AND COALESCE(g.ended_at, g.started_at) < $1) AS snake_turns,
-        (SELECT count(*) FROM game_snakes t JOIN games g USING (game_id)
-          WHERE g.has_replay AND g.quality_status = 'low_quality'
-            AND COALESCE(g.ended_at, g.started_at) < $1) AS game_snakes
+        (SELECT count(*) FROM game_replays r JOIN candidates c USING (gid)) AS replays,
+        (SELECT count(*) FROM game_turns t JOIN candidates c USING (gid)) AS turns,
+        (SELECT count(*) FROM game_snakes s JOIN candidates c USING (game_id)) AS game_snakes
     """, cutoff)
     print(
       f"candidates before {cutoff.isoformat()}: games={candidates:,}, "
-      f"turns={rows['turns']:,}, snake_turns={rows['snake_turns']:,}, "
+      f"replays={rows['replays']:,}, running turns={rows['turns']:,}, "
       f"game_snakes={rows['game_snakes']:,}"
     )
     if dry_run or candidates == 0:
@@ -50,8 +50,13 @@ async def cleanup(dsn: str, older_than_days: int, dry_run: bool, vacuum: bool) -
         FOR UPDATE
       """, cutoff)
       ids = [row["game_id"] for row in game_ids]
-      await connection.execute("DELETE FROM snake_turns WHERE game_id = ANY($1::text[])", ids)
-      await connection.execute("DELETE FROM turns WHERE game_id = ANY($1::text[])", ids)
+      # snake_states rows cascade from game_snakes.
+      await connection.execute("""
+        DELETE FROM game_replays WHERE gid IN (SELECT gid FROM games WHERE game_id = ANY($1::text[]))
+      """, ids)
+      await connection.execute("""
+        DELETE FROM game_turns WHERE gid IN (SELECT gid FROM games WHERE game_id = ANY($1::text[]))
+      """, ids)
       await connection.execute("DELETE FROM game_snakes WHERE game_id = ANY($1::text[])", ids)
       await connection.execute("""
         UPDATE games
@@ -62,8 +67,9 @@ async def cleanup(dsn: str, older_than_days: int, dry_run: bool, vacuum: bool) -
     if vacuum:
       await connection.execute("VACUUM (ANALYZE) games")
       await connection.execute("VACUUM (ANALYZE) game_snakes")
-      await connection.execute("VACUUM (ANALYZE) turns")
-      await connection.execute("VACUUM (ANALYZE) snake_turns")
+      await connection.execute("VACUUM (ANALYZE) game_replays")
+      await connection.execute("VACUUM (ANALYZE) game_turns")
+      await connection.execute("VACUUM (ANALYZE) snake_states")
       print("vacuum/analyze complete")
   finally:
     await connection.close()