feat: add server-side rendering building blocks (externals preset, SSR manifest, collected CSS) - #21444

Emitting at PROCESS_ASSETS_STAGE_SUMMARIZE let RealContentHashPlugin rewrite the
hashed filenames inside the already-emitted manifest, which invalidated the
persistent cache pack. Emit at PROCESS_ASSETS_STAGE_REPORT instead so filenames
are final and the manifest is not rewritten.

Drive a real universal SSR render that reads the SSR manifest for modulepreload
links and __webpack_css_server_styles__ for critical css, then assert the
composed HTML document ties both primitives together.

require("fs") in the universal module bundle resolved through the createRequire
external, which is not reliably callable in the ESM test runner on Node 10-18.
Use dynamic import(), matching the CSS SSR runtime's fs access.

Demonstrate SSRManifestPlugin, __webpack_css_server_styles__ and
externalsPresets.nodeModules composing into a server-side rendering flow.

Native CSS minification now applies in production, so the example's
recorded asset sizes changed.

`output.publicPath: "auto"` resolves in the browser from the script URL,
which a build-time manifest cannot do. Emitting the bare filename made
injected preloads resolve against the rendered page's URL, so a nested
route requested the wrong asset. Map it to "/" as `ManifestPlugin` does.

Also drop the redundant `experiments` from the example: `css` defaults to
"auto" and the universal target already implies `outputModule`.

Each module was mapped only to the chunk it lives in, so a route sharing
a split-out chunk left the client to discover that chunk after fetching
the route. Follow dependencies (never importers, which would drag in
unrelated routes) and async ancestors, matching what Vite's SSR manifest
describes.

Split the example into a client build and a Node render build so every SSR
building block is exercised end to end: both manifests side by side, the
CSS collected while rendering without a DOM, the node/nodeModules externals
presets, non-emitting asset modules, and import.meta.env.

The nested-async case exercises a route reached through another async chunk,
where the manifest has to list the ancestor the browser loads it through;
the validation case covers the plugin's schema-rejection path.

They are deliberately the wrong type, so the types-test project rejected the
literal.

getRequiredChunks walked every chunk module's outgoing connections per
chunk, so a module shared by N chunks had its connections iterated N
times. Collapse the module graph to chunk-to-chunk edges in a single pass
and walk those instead: 29.1ms -> 23.4ms on a 201-chunk build whose 800
shared modules each land in 200 chunks.

The no-DOM branch was selected from `environment.document` alone, which is
also false for `target: "webworker"` — routing a worker's CSS chunk loading
through `import('fs')`, which a worker cannot resolve. Require the node
platform as well, so every other document-less target keeps the link code it
had before.

The manifest sorted every file alphabetically, so a route split across two
stylesheets handed the server an arbitrary cascade — `alpha.css` before the
`page.css` its source imports first. Stylesheets now keep the order the
extracted HTML writes them in, and a config case pins that a `<link>` a server
printed is adopted by the browser runtime rather than requested again.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01K8n6KpLAPpLZdLrovcDnAu