refactor(game): lock-free storage, remove /command, flatten engine wrapper

Three-stage refactor of the game-engine plumbing (game logic untouched):

Stage 1 — lock-free persistence + admin serialisation. Remove the file
lock from repo/fs (the .lock file, the Read/Write-vs-*Safe duality and the
dead ReadSafe polling) and replace the two-step rename with a single atomic
rename so concurrent reads are torn-free without a lock. Serialise the
state-mutating admin writers (init/turn/banish) with one shared router
LimitMiddleware, rewritten to block on the request context instead of a
racy shared 100ms timer.

Stage 2 — remove the obsolete immediate-command path end to end. Players
submit through PUT /api/v1/order; the legacy PUT /api/v1/command path is
deleted across game (route, handler, 24 command factories, Ctrl), backend
(Commands handler/route, engineclient.ExecuteCommands), gateway (dispatch +
executeUserGamesCommand + routing entry), the FlatBuffers/model contract
(UserGamesCommand[Response]) and transcoder, plus every affected
OpenAPI/README/FUNCTIONAL/ARCHITECTURE doc. The integration proxy test is
converted to the order path.

Stage 3 — flatten the REST->engine wrapper. Replace the executor adapter,
the controller package functions and RepoController with one concrete
controller.Service; drop the single-implementation Repo and Storage
interfaces (repo.Repo / fs.FS are now concrete). Handlers depend on a thin
handler.Engine seam and own the domain->REST projection; storage is
resolved once at startup instead of per request.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

game/internal/router/router_helper_test.go

@@ -3,11 +3,13 @@ package router_test
 import (
 	"encoding/json"
 	"net/http"
+	"testing"
 
 	"galaxy/model/order"
 	"galaxy/model/report"
-	"galaxy/model/rest"
 
+	"galaxy/game/internal/controller"
+	"galaxy/game/internal/model/game"
 	"galaxy/game/internal/router"
 	"galaxy/game/internal/router/handler"
 
@@ -19,7 +21,6 @@ var (
 	commandNoErrorsStatus = http.StatusAccepted
 	commandDefaultActor   = "Gorlum"
 	apiCommandMethod      = "PUT"
-	apiCommandPath        = "/api/v1/command"
 	apiOrderPath          = "/api/v1/order"
 	validId1              = id()
 	validId2              = id()
@@ -81,25 +82,20 @@ func (e *dummyExecutor) FetchBattle(turn uint, ID uuid.UUID) (*report.BattleRepo
 	return e.FetchBattleResult, e.FetchBattleOK, e.FetchBattleErr
 }
 
-func (e *dummyExecutor) Execute(command ...handler.Command) error {
-	e.CommandsExecuted = len(command)
-	return nil
+func (e *dummyExecutor) GenerateGame(gameID uuid.UUID, races []string) (game.State, error) {
+	return game.State{ID: gameID}, nil
 }
 
-func (e *dummyExecutor) GenerateGame(gameID uuid.UUID, races []string) (rest.StateResponse, error) {
-	return rest.StateResponse{ID: gameID}, nil
-}
-
-func (e *dummyExecutor) GenerateTurn() (rest.StateResponse, error) {
-	return rest.StateResponse{}, nil
+func (e *dummyExecutor) GenerateTurn() (game.State, error) {
+	return game.State{}, nil
 }
 
 func (e *dummyExecutor) BanishRace(raceName string) error {
 	return nil
 }
 
-func (e *dummyExecutor) GameState() (rest.StateResponse, error) {
-	return rest.StateResponse{}, nil
+func (e *dummyExecutor) GameState() (game.State, error) {
+	return game.State{}, nil
 }
 
 func (e *dummyExecutor) LoadReport(actor string, turn uint) (*report.Report, error) {
@@ -110,14 +106,25 @@ func setupRouter() *gin.Engine {
 	return setupRouterExecutor(newExecutor())
 }
 
-func setupRouterExecutor(e handler.CommandExecutor) *gin.Engine {
+func setupRouterExecutor(e handler.Engine) *gin.Engine {
 	return router.SetupRouter(e)
 }
 
-func newExecutor() handler.CommandExecutor {
+func newExecutor() handler.Engine {
 	return &dummyExecutor{}
 }
 
+// newService builds a real controller.Service backed by a storage directory,
+// for handler tests that exercise the engine end to end rather than the fake.
+func newService(t *testing.T, root string) *controller.Service {
+	t.Helper()
+	svc, err := controller.NewService(root)
+	if err != nil {
+		t.Fatalf("new service: %v", err)
+	}
+	return svc
+}
+
 func encodeCommand(cmd any) json.RawMessage {
 	v, err := json.Marshal(cmd)
 	if err != nil {