feat(network-activity-plugin): virtualize large code blocks

[burczu]

Part of #244 — "Improve response viewing in Network Activity." Makes the response panel's CodeBlock threshold-aware so multi-megabyte text bodies don't pin hundreds of thousands of DOM nodes.

Summary

• CodeBlock becomes threshold-aware. When children is a string longer than 50,000 characters, the body renders inside a react-virtuoso <Virtuoso> and only the rows currently visible inside a 500 px window stay in the DOM. Below the threshold (and for any non-string children — <JsonTree>, <XmlTree> wrapped in CodeBlock for the monospace-on-dark frame), rendering is unchanged: a flat <pre>. The dispatch is a runtime typeof children === 'string' branch — zero changes required at any of the 11+ existing CodeBlock call sites (json / xml / svg / text-fallback renderers, malformed-fallback paths, RequestBody).
• Virtuoso configuration. Fixed style={{ height: 500 }} matches the visual scale of HexView and the iframe elsewhere in the response panel. <div> rows (Virtuoso positions rows absolutely and needs block-level items). Per-row whitespace-pre-wrap wrap-anywhere preserves today's wrapping UX so long URLs / base64 / minified-on-one-line content wrap visually instead of forcing horizontal scroll. Outer styling reuses the existing codeBlockClassNames constant so the dark bg / monospace / border / padding are identical between the two branches.
• Known shape limitation. A 50 KB body with no newlines virtualizes to a single row containing the entire payload. Browser-level wrapping keeps the layout sane but there's no real virtualization benefit for that shape — the perf win shows up once the body has many lines.
• UX trade-off worth knowing. Today's <pre> expands to content (height grows with body length). After this change, content above 50 KB scrolls inside a 500 px window. Deliberate, for snappy rendering on multi-megabyte responses.
• Adds react-virtuoso ^4.6.0 to @rozenite/network-activity-plugin's dependencies.
• Playground. A new "Large text" main-tab on NetworkTestScreen with two pre-verified URLs straddling the threshold so reviewers can see both branches: Alice in Wonderland from Gutenberg (~174 KB, virtualizes) and the GPL-3 license text (~35 KB, stays flat).

Test plan

• pnpm --filter @rozenite/network-activity-plugin test — all tests pass (8 new in CodeBlock.test.tsx).
• pnpm --filter @rozenite/network-activity-plugin typecheck — clean.
• pnpm --filter @rozenite/network-activity-plugin lint — clean.
• npx prettier --check on changed files — clean.
• Playground (pnpm --filter @rozenite/playground ios or :android) → Network Test → Large text tab:
  • Alice in Wonderland (~174 KB) — Response body scrolls inside a 500 px window. NOT an unbounded <pre>. Scrolling is smooth at the end of the ~3300-line file. Dark bg / monospace / border look identical to a small <pre>.
  • GPL-3 license (~35 KB) — Response body renders as a flat <pre>, height grows with content, no internal scrolling. (Control: confirms the threshold gating works.)
• JSON tree responses unchanged — open any JSON response (HTTP Test → User-list). Renders as JsonTree wrapped in CodeBlock as before. No virtualization (children is a React element, not a string).
• SVG Raw view unchanged — Images tab → SVG → toggle to Raw. Renders as flat <pre> with SVG source (SVG bodies are well under threshold).
• Toggle behavior unchanged — sticky Preview/Raw preference, override button presence, content-type label all work as before.

New test surface

components/__tests__/CodeBlock.test.tsx (8 tests):

• Small string content renders as <pre> with no virtuoso-mock present.
• Exactly 50,000 chars stays on the flat path (inclusive-boundary semantics — the branch condition is >, not >=).
• 50,001 chars switches to the virtualized rendering.
• Content survives the threshold split (recognizable head and tail tokens both visible in the DOM after virtualization).
• Newlines in virtualized content produce one row per line.
• React-element children stay on the <pre> path even when the wrapped element contains a 50,001-char string internally (the typeof children === 'string' check takes precedence).
• className forwarding on both the flat and virtualized branches.

vitest.setup.ts adds a vi.mock('react-virtuoso') passthrough so jsdom-based tests can assert content correctness. jsdom can't drive Virtuoso's resize observation otherwise — without the stub any test importing a virtualizing component fails to render rows. Production code is unaffected.

Followups (deliberately not in this PR)

• Search inside virtualized content.
• Truncation modes.
• Virtualizing trees (JsonTree, XmlTree) — would require forking react-json-tree or rewriting from scratch.
• Per-row line numbers in the virtualized branch.
• Syntax highlighting (cross-cutting feature; would also benefit XML / JSON / HTML Raw views).
• Programmatic line-wrapping for single-line content longer than the threshold (would require choosing a column width).

Coordination notes

• react-virtuoso dep + vi.mock('react-virtuoso') test stub are also added by feat(network-activity-plugin): binary hex viewer + metadata card #274 (binary hex viewer, ready for review). The lines are identical on both branches; whichever lands second will see a clean auto-merge (or a one-line trivial conflict on the dependencies block).
• network-activity.mdx Response Viewing section is also edited by feat(network-activity-plugin): HTML response renderer with sandboxed iframe #275 (HTML) and feat(network-activity-plugin): XML response renderer + JSON Raw view #277 (XML + JSON Raw). This PR appends a separate paragraph at the end of the section rather than touching their bullets — additive, no overlap.