feat(core): port v1.5 hook layer (#1243) (#1300)

* feat(core): port v1.5 hook layer (useInspectorClient + useManaged*/usePaged* + log hooks)

Wholesale port of v1.5's React hook layer and the EventTarget-based state machinery the hooks subscribe to (#1243). Hooks decouple from the concrete InspectorClient via a new `InspectorClientProtocol` interface so this layer can land before the runtime class is ported.

Added under `core/`:
- `core/react/` — useInspectorClient + 5 useManaged* + 5 usePaged* + 3 log hooks
- `core/mcp/state/` — 5 managed*State + 5 paged*State + messageLogState + stderrLogState + fetchRequestLogState
- `core/mcp/inspectorClientProtocol.ts`, `inspectorClientEventTarget.ts`, `typedEventTarget.ts`, `samplingCreateMessage.ts`, `sessionStorage.ts`
- v2-only wrapper types in `core/mcp/types.ts`: InspectorUrlElicitRequest, InspectorPendingRequest, InspectorRequestHistoryItem

Tests live under `clients/web/src/test/core/` (28 new test files, 264 new tests). Test fake: `core/mcp/__tests__/fakeInspectorClient.ts`.

Build wiring:
- `vite.config.ts`: dedupe react/react-dom so core/ files resolve them via clients/web/node_modules.
- `tsconfig.app.json` / `tsconfig.test.json`: paths map react/react-dom/vitest to clients/web/node_modules so `tsc -b` resolves bare imports from core/ source files (which sit above the package's node_modules). Exclude core/__tests__ from app config; include in test config.

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

* review: address PR #1300 review findings

Bugs:
- fetchRequestLogState: add .catch() on sessionStorage.loadSession so a corrupt
  or unreadable session doesn't surface as an unhandled rejection (matches the
  saveSession swallow pattern).
- messageLogState: sync pendingRequestEntries when clearMessages() evicts a
  pending request entry, so a later response with the same id falls through
  to the append branch instead of mutating an unreachable map entry. Add tests
  for both predicate and no-predicate paths.

Cleanups:
- Extract mergeTaskIntoList helper to core/mcp/state/mergeTaskIntoList.ts so
  managed/paged RequestorTasks state classes share one definition.
- Add a one-line JSDoc note on each PagedTools/Prompts/Resources/Templates
  state explaining why they deliberately do not subscribe to *ListChanged
  (cursor invalidation mid-pagination).
- Document on useInspectorClient that appRendererClient is read lazily on
  every render and is not subscribed (changes once at connect time).

Carry-overs from v1.5 deliberately left for the follow-up InspectorClient
runtime port:
- Refresh/status-change race in Managed*State.refresh() (status check is only
  at entry; a disconnect during await can re-clear before refresh resumes).
- nextCursor exposure asymmetry across usePaged* (only usePagedRequestorTasks
  surfaces it via state field; others return it from loadPage() only).

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

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

core/react/useManagedTools.ts

@@ -0,0 +1,49 @@
+import { useState, useEffect, useCallback } from "react";
+import type { InspectorClientProtocol } from "../mcp/inspectorClientProtocol.js";
+import type { ManagedToolsState } from "../mcp/state/managedToolsState.js";
+import type { ManagedToolsStateEventMap } from "../mcp/state/managedToolsState.js";
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { TypedEventGeneric } from "../mcp/typedEventTarget.js";
+
+export interface UseManagedToolsResult {
+  tools: Tool[];
+  refresh: () => Promise<Tool[]>;
+}
+
+/**
+ * React hook that subscribes to ManagedToolsState and returns tools + refresh.
+ */
+export function useManagedTools(
+  client: InspectorClientProtocol | null,
+  managedToolsState: ManagedToolsState | null,
+): UseManagedToolsResult {
+  const [tools, setTools] = useState<Tool[]>(
+    managedToolsState?.getTools() ?? [],
+  );
+
+  useEffect(() => {
+    if (!managedToolsState) {
+      setTools([]);
+      return;
+    }
+    setTools(managedToolsState.getTools());
+    const onToolsChange = (
+      event: TypedEventGeneric<ManagedToolsStateEventMap, "toolsChange">,
+    ) => {
+      setTools(event.detail);
+    };
+    managedToolsState.addEventListener("toolsChange", onToolsChange);
+    return () => {
+      managedToolsState.removeEventListener("toolsChange", onToolsChange);
+    };
+  }, [managedToolsState]);
+
+  const refresh = useCallback(async (): Promise<Tool[]> => {
+    if (!managedToolsState || !client) return [];
+    const next = await managedToolsState.refresh();
+    setTools(next);
+    return next;
+  }, [client, managedToolsState]);
+
+  return { tools, refresh };
+}