refactor(extension): class-based command registry + modular src layout

Restructure the MV3 background worker from a monolithic core.ts/index.ts
into a class-based command architecture. Behavior is identical — the 83
registered commands dispatch byte-for-byte the same as before.

Structure
- One class per command group, each extending CommandGroup and exporting a
  `commands` map keyed by the full command id ("tabs.close"). Groups:
  Navigation, TabsMutation, TabsQuery, Groups, Windows, Dom (dom/extract/
  page), BrowserData (storage/cookies), Session (session/clients + autosave
  + lazy-tab activation), Perf (perf + jobs.status/cancel), Extension.
- CommandRegistry merges the group maps (throws on duplicate ids), routes
  background specs to JobManager and paginates array results via
  makePagedData. JobManager owns the job map + lifecycle. NativeConnection
  owns the native-port lifecycle and the inbound message router.
- index.ts is now thin wiring: JobManager -> ctx -> assembleRegistry ->
  onActivated -> NativeConnection.start().
- Infra classes live in classes/ (PascalCase, file = class name); command
  groups in commands/; shared helpers split out of core.ts into core/
  (errors, throttle, scripting, tab-helpers, group-helpers, storage); all
  types moved into types/ (json, jobs, session, tabs, messages,
  command-args) behind a barrel.

DRY cleanup
- resolveTabUrl(tabId) and assertScriptableUrl(url, action) collapse the
  tab/URL-guard boilerplate duplicated across dom.ts and browser-data.ts.
- processInBatches() centralizes the throttled, cancellable batch loop
  shared by tabs.close, group.close and tabs.merge_windows.
- captureCurrentSession() dedups the snapshot-and-signature block shared by
  session.save and the autosave path.
- DomArgs type alias replaces 21 inline ContentArgs & { tabId? } copies.
- Drop fetchTabHtml's redundant retry loop (executeScript already retries
  transient frame/tab errors), a dead tabInfo import, and two stale
  comments referencing a removed asArgs helper.

Type safety & tests
- Full noImplicitAny; no `any`/`unknown` annotations remain in src.
- JS unit-test harness using node --test + node:assert (zero new deps),
  bundled via the existing esbuild. Covers JobManager retention/lifecycle
  and the autosave listener-wiring/debounce with an in-memory chrome mock.
- The structural pytest checks track the new file homes and the centralized
  processInBatches helper.

Verification: npm run check:extension green (tsc + esbuild 84.5kb +
node --check + 18 JS tests); uv run pytest -q -> 409 passed, 105 skipped.
No version bump.

extension/test/chrome-mock.ts

@@ -0,0 +1,55 @@
+// @ts-nocheck
+import { mock } from 'node:test';
+
+/**
+ * Minimal in-memory chrome.* stub for service-worker unit tests.
+ * Only the surface the tested modules touch is implemented.
+ * Mock functions use node:test's `mock.fn` (callCount/resetCalls via `.mock`).
+ */
+export function makeChromeMock() {
+  const store: Record<string, any> = {};
+  const listeners = new Map<string, Set<Function>>();
+
+  function event(name: string) {
+    if (!listeners.has(name)) listeners.set(name, new Set());
+    const set = listeners.get(name)!;
+    return {
+      addListener: (fn: Function) => set.add(fn),
+      removeListener: (fn: Function) => set.delete(fn),
+      hasListener: (fn: Function) => set.has(fn),
+      // test helper: count registered listeners
+      _size: () => set.size,
+    };
+  }
+
+  return {
+    storage: {
+      local: {
+        get: mock.fn(async (key: string | string[]) => {
+          const keys = Array.isArray(key) ? key : [key];
+          const out: Record<string, any> = {};
+          for (const k of keys) if (k in store) out[k] = store[k];
+          return out;
+        }),
+        set: mock.fn(async (obj: Record<string, any>) => {
+          Object.assign(store, obj);
+        }),
+        _store: store,
+      },
+    },
+    tabs: {
+      query: mock.fn(async () => []),
+      onCreated: event('tabs.onCreated'),
+      onRemoved: event('tabs.onRemoved'),
+      onMoved: event('tabs.onMoved'),
+      onAttached: event('tabs.onAttached'),
+      onDetached: event('tabs.onDetached'),
+      onUpdated: event('tabs.onUpdated'),
+    },
+    tabGroups: {
+      query: mock.fn(async () => []),
+      onUpdated: event('tabGroups.onUpdated'),
+    },
+    _event: event,
+  };
+}