Problem

lazy_loaded_js extension scripts (the ones loaded via loadExtScript / compile_function) were being baked
into the V8 startup snapshot as owned source-string copies on the V8 heap. Every one of these sources
landed in mutable ("dirty") snapshot heap pages, which means:

• the isolate blob carried a full copy of each lazy script's source text, and
• deserialization had to materialize and fix up those string objects on every startup.

This is wasteful: the source text is immutable and already lives in the binary as a &'static string (via
include_str!). It never needs to be a heap-allocated, snapshot-serialized V8 string.

Fix

Externalize lazy_loaded_js sources so they stay off the V8 heap, backed directly by the static string in
the binary:

1. Pre-wrap at build time. loadExtScript evaluates each source as the body of a compile_function call
   ("use strict"; return (<IIFE>);). That wrapping is now done once at snapshot-build time
   (wrap_lazy_ext_script in cli/snapshot/build.rs + extension_set.rs) so the stored source is the exact
   &'static string V8 compiles — no per-script owned copy. map.rs detects the wrapped prefix and hands V8 the
   external string directly; sources that arrive unwrapped (e.g. consumed during snapshot creation) still get
   wrapped at runtime as a fallback.

2. Externalize only when building the snapshot. externalize_sources now externalizes lazy_loaded_js
   (in addition to js + esm + lazy_esm) only under will_snapshot. At runtime these stay as static
   registrations; consumed ones re-link to the snapshot's external backing. The source/external-reference counts
   in externalize_sources and jsruntime.rs are kept exactly in sync — a mismatch leaves uninitialized
   external-reference slots that shift snapshot indices and miscompile JIT'd code that references them.

3. Don't duplicate residual sources. Only consumed lazy scripts are actually referenced by snapshotted
   code. Non-consumed (residual) scripts are already shipped via the residual table, so persisting their bytes in
   the snapshot sidecar would duplicate them. At serialize time we store empty bytes for non-consumed
   lazy-script slots (keeping the external-reference index for alignment, since nothing references it).

Impact

• ~46% smaller isolate blob (the dirty source copies are gone).
• ~0.6 ms faster cold startup (less deserialization fixup), measured locally with
  --v8-flags=--profile-deserialization.
• No behavior change: lazy scripts compile and run identically (strict-mode body, IIFE completion value
  preserved).