Refactor: Move module-level mutable flags to JailServiceState

TASK-004: Replace module-level mutable runtime flags in service layer with
injected state holder, eliminating hidden global state and improving testability
and synchronization boundaries.

Changes:
- Create JailServiceState dataclass in app/utils/runtime_state.py to hold
  backend capability cache and synchronization lock
- Add JailServiceState as a field in RuntimeState (with default_factory)
- Remove module-level _backend_cmd_supported and _backend_cmd_lock from
  jail_service.py
- Refactor _check_backend_cmd_supported() to accept state parameter
- Inject JailServiceState into list_jails() and _fetch_jail_summary() via
  parameters
- Add get_jail_service_state() dependency provider in app/dependencies.py
- Add JailServiceStateDep type alias for router injection
- Update jails router to receive and pass state to service functions
- Update all tests to use jail_service_state fixture and pass state to functions
- Remove duplicate _MAX_PAGE_SIZE constant definition
- Document mutable state management in Backend-Development.md
- Update Architecture.md to describe JailServiceState and state nesting pattern

Benefits:
- Eliminates global mutable state and associated race conditions
- Makes state visible to callers (not hidden in module scope)
- Enables test isolation (each test gets fresh state)
- Prepares codebase for multi-worker deployments (state can be extracted to
  shared backend)
- Synchronization boundaries are now explicit (state.get_backend_cmd_lock())

Compliance:
- All tests pass (17 passed in TestListJails, TestGetJail, TestLockInitialization)
- No ruff linting errors
- Type-safe: JailServiceState properly typed with asyncio.Lock, bool | None

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Docs/Backend-Development.md

@@ -174,6 +174,44 @@ async def get_history(
 
 This pattern prevents circular imports, makes services testable, and allows easy mocking in tests.
 
+### Mutable Runtime State
+
+All mutable runtime state (state that changes during the application's lifetime) **must** be stored in `RuntimeState` defined in `app/utils/runtime_state.py`. This centralizes state management, prevents accidental global mutable variables, and makes state management testable and synchronization-safe.
+
+**Allowed locations for mutable state:**
+
+1. **RuntimeState fields** — Core application state (e.g., `server_status`, `last_activation`, `pending_recovery`, `runtime_settings`). Managed through dedicated functions (e.g., `record_activation()`, `clear_pending_recovery()`).
+2. **Nested service state** — Service-specific mutable state (e.g., `JailServiceState` for jail capability detection cache) is nested within `RuntimeState` as a field. Services receive their state via dependency injection.
+3. **Controlled via dependencies** — State is injected into services and routers using FastAPI `Depends()`. This ensures single-source-of-truth and testability.
+
+**Example — jail_service state management:**
+
+```python
+# Define service-specific state (in app/utils/runtime_state.py)
+@dataclass
+class JailServiceState:
+    backend_cmd_supported: bool | None = None
+    backend_cmd_lock: asyncio.Lock | None = None
+
+# Nested in RuntimeState
+@dataclass
+class RuntimeState:
+    jail_service_state: JailServiceState = field(default_factory=JailServiceState)
+    ...
+
+# Injected into services via dependency
+async def list_jails(socket_path: str, state: JailServiceState) -> JailListResponse:
+    backend_cmd_is_supported = await _check_backend_cmd_supported(client, name, state)
+    ...
+
+# Routers inject state through FastAPI dependencies
+@router.get("/api/jails")
+async def get_jails(state: JailServiceStateDep) -> JailListResponse:
+    return await jail_service.list_jails(socket_path, state)
+```
+
+**Why:** Centralizing mutable state prevents race conditions, makes concurrency boundaries explicit, simplifies testing (each test gets a fresh state object), and prepares for multi-worker deployments (shared state would need to be extracted to Redis, database, or shared memory).
+
 ---
 
 ## 4. FastAPI Conventions