Add ENet multiplayer (movement/combat sync) and matchmaking API

Networked play, end to end: connect, get matched, spawn, fight, respawn.

Godot side:
- Replace the single hardcoded Player with per-peer networked ships
  (MultiplayerSpawner + custom spawn_function), driven by client-side
  prediction with server reconciliation for movement.
- Server-authoritative combat: bullets, health, death/respawn all decided
  by the server and broadcast to every peer over RPC.
- Fix a Camera2D bug where Godot auto-promotes the first camera to ever
  enter the scene tree as the active one regardless of its own `current`
  value — with MultiplayerSpawner catch-up replication that was almost
  never the local player's own ship. `make_current()` on the owner's
  camera fixes it; property assignment doesn't reliably override the
  auto-claim.
- Fix two "late joiner never learns already-established state" gaps
  (health, visibility) by folding both into the existing per-tick
  position broadcast instead of relying on one-shot RPCs that only reach
  peers already connected when they fire.
- Make the 2 offered factions in team select match for every player in
  a match: the server decides once and clients either read it directly
  (server's own instance) or request it over RPC, rather than each
  client rolling its own random pair.
- New MatchmakingClient autoload wires the main menu's CASUAL/RANKED
  buttons to the matchmaking API instead of connecting directly.

New matchmaking-api/ (FastAPI + Postgres, Docker Compose):
- Queue/match/stats/ranks endpoints. In-memory matchmaking queue in a
  single API process — no Redis until there's an actual reason to shard
  the queue across instances.
- Background loop forms a match once enough players are queued for a
  mode, assigns the first available registered game server.
- No real server pool yet: one dev server is auto-seeded from
  DEV_SEED_SERVER_IP/PORT; POST /servers/register exists for real
  servers to self-register later but nothing calls it yet.

Docs: CLAUDE.md and overview/tech.md updated to match — networking
checklist mostly checked off, matchmaking backend section rewritten to
describe what was actually built vs. the original Go/Redis plan, and
Current Tasks reordered around what's actually left (bot fill, real
server pool, ranked/MMR refinement, lag compensation).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

matchmaking-api/app/routers/servers.py

@@ -0,0 +1,44 @@
+from datetime import datetime
+
+from fastapi import APIRouter, Depends
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database import get_db
+from app.models import GameServer, ServerStatus
+from app.schemas import ServerRegisterRequest
+
+router = APIRouter(prefix="/servers", tags=["servers"])
+
+
+# Real game servers should call this on boot and periodically (heartbeat) once
+# NetworkManager grows that integration. Until then, a dev server is seeded
+# on API startup (see main.py) from DEV_SEED_SERVER_IP/PORT so matchmaking is
+# testable end-to-end without it.
+@router.post("/register")
+async def register_server(req: ServerRegisterRequest, db: AsyncSession = Depends(get_db)) -> dict:
+    existing = (
+        await db.execute(select(GameServer).where(GameServer.ip == req.ip, GameServer.port == req.port, GameServer.mode == req.mode))
+    ).scalars().first()
+    if existing:
+        existing.status = ServerStatus.available
+        existing.last_heartbeat = datetime.utcnow()
+    else:
+        db.add(GameServer(ip=req.ip, port=req.port, mode=req.mode, status=ServerStatus.available))
+    await db.commit()
+    return {"status": "registered"}
+
+
+@router.get("")
+async def list_servers(db: AsyncSession = Depends(get_db)) -> list[dict]:
+    servers = (await db.execute(select(GameServer))).scalars().all()
+    return [
+        {
+            "ip": s.ip,
+            "port": s.port,
+            "mode": s.mode,
+            "status": s.status,
+            "last_heartbeat": s.last_heartbeat,
+        }
+        for s in servers
+    ]