Loading a package made the kernel parse the package's entire `.jsii`
assembly up front, even though a given execution only ever looks up a
tiny fraction of the declared types (often well under 1%). For large
assemblies such as aws-cdk-lib this is tens of megabytes of JSON parsed
to use a few hundred kilobytes of it.

When a package is served from the on-disk package cache, the kernel now
builds a compact "runtime index" alongside the cached assembly: a header
plus, for every type, its kind and the byte range of its (documentation-
stripped) definition within a single bodies blob. Type definitions are
then parsed lazily, on first lookup, so untouched types are never parsed.

The index is built once per cached package the first time it is loaded --
whether it was just extracted or had been cached by an earlier run that
predates this feature -- and carries a format version so that changing
the layout transparently invalidates and rebuilds older indices. Building
and using the index is strictly best-effort: validation loads, uncached
loads, and any read/write failure fall back to a full eager parse, so
correctness never depends on the cache.

… file

Replaces the JSON-object-per-type index with a columnar binary layout, and
makes the on-disk format self-describing.

The cache entry now holds two files:

  .jsii.runtime.v1.json        small manifest (schema, version, data path,
                               assembly metadata, byte layout)
  .jsii.runtime-index.v1       binary data file with four contiguous regions
                               laid out as
                                 names   : "fqn0
fqn1
..."  (UTF-8)
                                 kinds   : uint8 per type     (TypeKind ordinal)
                                 offsets : uint32le[N+1]      (into defs)
                                 defs    : type-definition JSON, doc-stripped

LazyTypes now consumes the columns directly: kinds and offsets are read as
typed-array views over the file (zero parsing), only the names blob is decoded,
and a type definition's bytes are sliced from the defs region and JSON-parsed
on first lookup. On aws-cdk-lib (~20k types) this is ~3.3x faster to load and
~43% smaller than the previous JSON map.

Both filenames are versioned, so a cache entry shared by multiple jsii
runtimes of different format versions never has one version clobber another's
files. The version is recorded both in the manifest filename and in a `version`
field inside the manifest, as an integrity check. The data file's path is also
recorded inside the manifest (defaulting to the versioned basename); the reader
resolves it relative to the manifest's directory and rejects absolute paths or
`..` traversal as defense-in-depth against a tampered or corrupted cache.

The format is also documented under
gh-pages/content/specification/7-runtime-index.md.

Test isolation: the kernel test suite previously read and pruned the
developer's real package cache via `defaultCacheRoot()`, which has caused
flakes when prior runs leave the cache inconsistent. A jest globalSetup now
points `JSII_RUNTIME_PACKAGE_CACHE_ROOT` at a fresh tmpdir for the duration
of the run (with a matching teardown), and `kernel.test.ts`'s afterAll prune
honours the override.