local-dev: boot-time dev sandbox provisions a runnable game on up

Adds backend/internal/devsandbox: an idempotent boot-time hook that,
when BACKEND_DEV_SANDBOX_EMAIL is set, ensures (1) the configured
engine_version row, (2) the real dev user, (3) PlayerCount-1
deterministic dummy users, (4) a private "Dev Sandbox" game with a
year-out turn schedule, (5) memberships for every participant via
the new lobby.Service.InsertMembershipDirect helper, (6) a drive of
the lifecycle to running. Re-running on a populated DB is a no-op;
partial states from earlier crashes are recovered.

tools/local-dev gains the matching env vars in .env, surfaces them
in compose, and acquires a `make build-engine` target that builds
galaxy-engine:local-dev from game/Dockerfile (a prerequisite of
`up`/`rebuild`). The compose game-state mount is changed from a
named volume to a host bind on /tmp/galaxy-game-state so backend's
bind-mount source for spawned engine containers resolves on the
docker daemon.

After `make -C tools/local-dev up`, login as dev@local.test with
the dev code 123456 and the Dev Sandbox already shows up in My
Games. Per-user behaviour for the same email survives a backend
restart.

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

tools/local-dev/README.md

@@ -35,6 +35,11 @@ pnpm -C ui/frontend dev
 Open <http://localhost:5173> for the UI and
 <http://localhost:8025> for Mailpit.
 
+The first `make up` builds the engine image (`galaxy-engine:local-dev`)
+from `game/Dockerfile`. Subsequent invocations skip the build when the
+image already exists; force a rebuild with `docker rmi galaxy-engine:local-dev`
+followed by `make build-engine`.
+
 ## Daily flow
 
 ```sh
@@ -69,6 +74,42 @@ To force the second path (no fast-bypass), edit
 `make rebuild` (or simply `docker compose up -d backend` to recreate
 the backend with the new env).
 
+## Auto-provisioned dev sandbox
+
+`make up` provisions a private game called **Dev Sandbox** owned by
+the dev user (default `dev@local.test`). The flow is implemented in
+`backend/internal/devsandbox` and runs on every backend boot when
+`BACKEND_DEV_SANDBOX_EMAIL` is non-empty in `tools/local-dev/.env`.
+
+Bootstrap is idempotent — re-running `make up` after a `make down`
+finds the existing user, dummy participants, game, and memberships
+without creating duplicates. If a previous boot crashed mid-way
+(game stuck in `enrollment_open` or `ready_to_start`), the next boot
+resumes the lifecycle.
+
+To log in straight into the sandbox:
+
+1. `make -C tools/local-dev up`
+2. `pnpm -C ui/frontend dev` (in another terminal)
+3. Open <http://localhost:5173/login>, enter `dev@local.test`, then
+   the dev code `123456`.
+4. The lobby shows **Dev Sandbox** in *My Games*; click in.
+
+To disable the bootstrap, clear `BACKEND_DEV_SANDBOX_EMAIL` in
+`tools/local-dev/.env` and `docker compose up -d backend` (or
+`make rebuild`). Existing users / games are not removed.
+
+The bootstrap requires:
+- `galaxy-engine:local-dev` Docker image (`make build-engine`).
+- `BACKEND_DEV_SANDBOX_ENGINE_VERSION` parses as plain semver
+  (`MAJOR.MINOR.PATCH`); the default `0.1.0` is what the bootstrap
+  registers in the `engine_versions` row that points at the image.
+- `BACKEND_DEV_SANDBOX_PLAYER_COUNT` ≥ 20 (the engine's minimum;
+  19 deterministic dummies fill the slots so the single real user
+  can start the game).
+- A frozen turn schedule (`0 0 1 1 *` — once a year) so the visible
+  game state stays at turn 1 until you explicitly progress it.
+
 ## Network map
 
 ```
@@ -105,8 +146,9 @@ To point the proxy at a non-local gateway, run
 ## Make targets
 
 ```text
-make up             Bring up the stack (build if needed) and wait for health
+make up             Bring up the stack (build engine + compose images if needed) and wait for health
 make rebuild        Rebuild the backend / gateway images (ignores cache)
+make build-engine   Build galaxy-engine:local-dev from game/Dockerfile (no-op if image already present)
 make down           Stop containers, keep volumes
 make clean          Stop and wipe volumes (postgres + game-state)
 make logs           Tail every service's logs