feat(startup_profiler): add StartupProfiler for per-phase init timing

Lightweight, in-memory profiler for AppController init phases. Used by
the startup_speedup_20260606 track to measure where the time goes
during boot (config hydration, hook server start, subsystem init, etc.).

The profiler is exposed via /api/startup_profile (Phase 8 work) and
the Diagnostics panel so the user can see the exact per-phase cost.

Public API:
  StartupProfiler() - create
  .phase(name) - context manager
  .snapshot() - {phases: {name: {start_ts, duration_ms}}, total_ms, count}
  .reset() - clear recorded phases
  .enable() / .disable() - toggle recording

Implementation:
  - dataclass with list of _Phase(name, start_ts, end_ts)
  - @contextmanager records wall-clock via time.perf_counter
  - records duration even if the body raises (try/finally)
  - snapshot is a copy, so consumers can't mutate the live state

TDD: 5 tests in tests/test_startup_profiler.py cover: basic
recording, total math, snapshot isolation, exception safety, empty
state.

src/startup_profiler.py

@@ -0,0 +1,54 @@
+import time
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from typing import Any, Iterator
+
+
+@dataclass
+class _Phase:
+ name: str
+ start_ts: float
+ end_ts: float = 0.0
+
+
+@dataclass
+class StartupProfiler:
+ _phases: list[_Phase] = field(default_factory=list)
+ _enabled: bool = True
+
+ def enable(self) -> None:
+  self._enabled = True
+
+ def disable(self) -> None:
+  self._enabled = False
+
+ @contextmanager
+ def phase(self, name: str) -> Iterator[None]:
+  if not self._enabled:
+   yield
+   return
+  p = _Phase(name=name, start_ts=time.perf_counter())
+  try:
+   yield
+  finally:
+   p.end_ts = time.perf_counter()
+   self._phases.append(p)
+
+ def snapshot(self) -> dict[str, Any]:
+  phases: dict[str, dict[str, float]] = {}
+  total = 0.0
+  for p in self._phases:
+   duration_ms = max(0.0, (p.end_ts - p.start_ts) * 1000.0) if p.end_ts else 0.0
+   phases[p.name] = {
+    "start_ts": p.start_ts,
+    "duration_ms": round(duration_ms, 3),
+   }
+   total += duration_ms
+  return {
+   "phases": phases,
+   "total_ms": round(total, 3),
+   "count": len(phases),
+  }
+
+ def reset(self) -> None:
+  self._phases.clear()