feat(multiplayer): add server process/assignment-ready registration API

Add POST /v1/servers/{id}/register (and its /api/v1 contract alias),
authenticated by the same workload binding as the result route. A
game server reports its protocol version and image digest and asks
to advance ALLOCATING -> PROCESS_READY -> ASSIGNMENT_READY; the store
boundary (AdvanceServerRegistration) does this as one idempotent
SERIALIZABLE transaction that also advances every participant's queue
ticket, and gates the final transition on every participant having a
live, unexpired assignment.

Adversarial review of the surrounding routing turned up a pre-existing
bug: contractServerMutation rejected any path containing '/', so the
already-documented /api/v1/servers/{id}/result route (and this new
/register route) 404'd for every real caller despite being declared
in the OpenAPI contract. Fix it to delegate shape validation to
serverMutation, matching how contractQueueMutation handles its own
two-segment paths, and add a regression test covering both contract
routes end to end.

server/store/allocation_match_sql.go

@@ -3,6 +3,7 @@ package store
 import (
 	"bytes"
 	"context"
+	"crypto/sha256"
 	"database/sql"
 	"fmt"
 	"time"
@@ -62,6 +63,73 @@ const ReleaseAllocatedMatchClaimSQL = `UPDATE matches
 SET allocation_id = NULL, allocation_claimed_at = NULL
 WHERE match_id = $1 AND state = 'ALLOCATING' AND allocation_id = $2 AND server_id IS NULL`
 
+const AdvanceServerRegistrationSQL = `WITH matched AS (
+    UPDATE matches
+    SET state = $4, revision = revision + 1
+    WHERE match_id = $1 AND server_id = $2 AND state = $3 AND protocol_version = $7
+      AND EXISTS (SELECT 1 FROM allocations WHERE match_id = $1 AND server_id = $2 AND allocation_id = $5 AND protocol_version = $7 AND state = 'ALLOCATED')
+      AND ($4 <> 'ASSIGNMENT_READY' OR (SELECT count(*) FROM assignments WHERE match_id = $1 AND expires_at > $6) = (SELECT count(*) FROM match_participants WHERE match_id = $1))
+    RETURNING match_id
+), advanced AS (
+    UPDATE queue_tickets q
+    SET state = $4, revision = revision + 1
+    FROM match_participants mp JOIN matched m ON m.match_id = mp.match_id
+    WHERE q.ticket_id = mp.ticket_id AND q.player_id = mp.player_id AND q.state = $3
+    RETURNING q.ticket_id
+)
+SELECT (SELECT count(*) FROM matched), (SELECT count(*) FROM match_participants WHERE match_id = $1), (SELECT count(*) FROM advanced)`
+
+const ServerRegistrationIdempotencyScope = "server.register"
+
+const ServerRegistrationIdempotencyInsertSQL = `INSERT INTO idempotency_keys
+    (scope, idempotency_key, payload_digest, result)
+VALUES ($1, $2, $3, '{}')
+ON CONFLICT (scope, idempotency_key) DO NOTHING`
+
+const ServerRegistrationIdempotencySelectSQL = `SELECT payload_digest
+FROM idempotency_keys
+WHERE scope = $1 AND idempotency_key = $2
+FOR UPDATE`
+
+func AdvanceServerRegistration(ctx context.Context, db *sql.DB, binding domain.WorkloadBinding, protocol int, assignmentReady bool, idempotencyKey string, now time.Time) error {
+	if db == nil || binding.MatchID == "" || binding.ServerID == "" || binding.AllocationID == "" || protocol < 1 || len(idempotencyKey) < 16 || len(idempotencyKey) > 128 || now.IsZero() {
+		return fmt.Errorf("invalid server registration")
+	}
+	from, to := domain.Allocating, domain.ProcessReady
+	if assignmentReady {
+		from, to = domain.ProcessReady, domain.AssignmentReady
+	}
+	digest := sha256.Sum256([]byte(fmt.Sprintf("%s\x00%s\x00%s\x00%d\x00%t", binding.AllocationID, binding.MatchID, binding.ServerID, protocol, assignmentReady)))
+	return RunSerializable(ctx, db, DefaultSerializableAttempts, func(ctx context.Context, tx *sql.Tx) error {
+		inserted, err := tx.ExecContext(ctx, ServerRegistrationIdempotencyInsertSQL, ServerRegistrationIdempotencyScope, idempotencyKey, digest[:])
+		if err != nil {
+			return err
+		}
+		changed, err := inserted.RowsAffected()
+		if err != nil {
+			return err
+		}
+		if changed == 0 {
+			var prior []byte
+			if err := tx.QueryRowContext(ctx, ServerRegistrationIdempotencySelectSQL, ServerRegistrationIdempotencyScope, idempotencyKey).Scan(&prior); err != nil {
+				return err
+			}
+			if !bytes.Equal(prior, digest[:]) {
+				return domain.ErrConflict
+			}
+			return nil
+		}
+		var matched, participants, advanced int
+		if err := tx.QueryRowContext(ctx, AdvanceServerRegistrationSQL, binding.MatchID, binding.ServerID, from, to, binding.AllocationID, now, protocol).Scan(&matched, &participants, &advanced); err != nil {
+			return err
+		}
+		if matched != 1 || participants == 0 || advanced != participants {
+			return domain.ErrConflict
+		}
+		return nil
+	})
+}
+
 // FindProviderAllocation verifies whether a recovered lease has already
 // crossed the durable provider boundary. A worker can then bind it without
 // issuing a second external allocation request after a crash.

server/store/allocation_match_sql_test.go

@@ -13,6 +13,9 @@ func TestAllocationMatchClaimSQLFencesConcurrentWorkers(t *testing.T) {
 		AllocatingMatchBuildSQL:           {"match_participants", "queue_tickets", "ORDER BY q.client_build"},
 		BindAllocatedMatchParticipantsSQL: {"allocation_id = $2", "server_id IS NULL", "SET server_id = $3", "FROM allocations", "state = 'ALLOCATING'", "revision = revision + 1"},
 		ReleaseAllocatedMatchClaimSQL:     {"allocation_id = $2", "allocation_id = NULL", "allocation_claimed_at = NULL"},
+		AdvanceServerRegistrationSQL:      {"state = $4", "protocol_version = $7", "ASSIGNMENT_READY", "revision = revision + 1"},
+		ServerRegistrationIdempotencyInsertSQL: {"idempotency_keys", "ON CONFLICT (scope, idempotency_key) DO NOTHING", "payload_digest"},
+		ServerRegistrationIdempotencySelectSQL: {"scope = $1", "idempotency_key = $2", "FOR UPDATE"},
 	}
 	for query, fragments := range checks {
 		for _, fragment := range fragments {