Add game data seeding from PokeAPI with level ranges

Seed the database with Pokemon game data for 5 games (FireRed, LeafGreen,
Emerald, HeartGold, SoulSilver) using pokebase. Includes Alembic migrations
for route unique constraints and encounter level ranges, a two-phase seed
system (offline fetch to JSON, then idempotent upserts), and Dockerfile
updates for the seed runner.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

backend/src/app/seeds/run.py

@@ -0,0 +1,120 @@
+"""Seed runner — reads JSON files and upserts into the database."""
+
+import json
+from pathlib import Path
+
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.database import async_session
+from app.models.game import Game
+from app.models.pokemon import Pokemon
+from app.models.route import Route
+from app.models.route_encounter import RouteEncounter
+from app.seeds.loader import (
+    upsert_games,
+    upsert_pokemon,
+    upsert_route_encounters,
+    upsert_routes,
+)
+
+DATA_DIR = Path(__file__).parent / "data"
+
+GAME_FILES = ["firered", "leafgreen", "emerald", "heartgold", "soulsilver"]
+
+
+def load_json(filename: str) -> list[dict]:
+    path = DATA_DIR / filename
+    with open(path) as f:
+        return json.load(f)
+
+
+async def seed():
+    """Run the full seed process."""
+    print("Starting seed...")
+
+    async with async_session() as session:
+        async with session.begin():
+            # 1. Upsert games
+            games_data = load_json("games.json")
+            slug_to_id = await upsert_games(session, games_data)
+            print(f"Games: {len(slug_to_id)} upserted")
+
+            # 2. Upsert Pokemon
+            pokemon_data = load_json("pokemon.json")
+            dex_to_id = await upsert_pokemon(session, pokemon_data)
+            print(f"Pokemon: {len(dex_to_id)} upserted")
+
+            # 3. Per game: upsert routes and encounters
+            total_routes = 0
+            total_encounters = 0
+
+            for game_slug in GAME_FILES:
+                game_id = slug_to_id.get(game_slug)
+                if game_id is None:
+                    print(f"Warning: game '{game_slug}' not found, skipping")
+                    continue
+
+                routes_data = load_json(f"{game_slug}.json")
+                route_map = await upsert_routes(session, game_id, routes_data)
+                total_routes += len(route_map)
+
+                for route in routes_data:
+                    route_id = route_map.get(route["name"])
+                    if route_id is None:
+                        print(f"  Warning: route '{route['name']}' not found")
+                        continue
+
+                    enc_count = await upsert_route_encounters(
+                        session, route_id, route["encounters"], dex_to_id
+                    )
+                    total_encounters += enc_count
+
+                print(f"  {game_slug}: {len(route_map)} routes")
+
+            print(f"\nTotal routes: {total_routes}")
+            print(f"Total encounters: {total_encounters}")
+
+    print("Seed complete!")
+
+
+async def verify():
+    """Run post-seed verification checks."""
+    print("\n--- Verification ---")
+
+    async with async_session() as session:
+        # Overall counts
+        games_count = (await session.execute(select(func.count(Game.id)))).scalar()
+        pokemon_count = (await session.execute(select(func.count(Pokemon.id)))).scalar()
+        routes_count = (await session.execute(select(func.count(Route.id)))).scalar()
+        enc_count = (await session.execute(select(func.count(RouteEncounter.id)))).scalar()
+
+        print(f"Games: {games_count}")
+        print(f"Pokemon: {pokemon_count}")
+        print(f"Routes: {routes_count}")
+        print(f"Route Encounters: {enc_count}")
+
+        # Per-game breakdown
+        result = await session.execute(
+            select(Game.name, func.count(Route.id))
+            .join(Route, Route.game_id == Game.id)
+            .group_by(Game.name)
+            .order_by(Game.name)
+        )
+        print("\nRoutes per game:")
+        for row in result:
+            print(f"  {row[0]}: {row[1]}")
+
+        # Per-game encounter counts
+        result = await session.execute(
+            select(Game.name, func.count(RouteEncounter.id))
+            .join(Route, Route.game_id == Game.id)
+            .join(RouteEncounter, RouteEncounter.route_id == Route.id)
+            .group_by(Game.name)
+            .order_by(Game.name)
+        )
+        print("\nEncounters per game:")
+        for row in result:
+            print(f"  {row[0]}: {row[1]}")
+
+    print("\nVerification complete!")