Worker-side clj analyzer execution. Mirrors the env-construction and
`analyze-form` body that live in `skeptic.analysis.annotate`, with no
Skeptic / Schema / Malli dependency. The worker reads the project's own
source files with the real Clojure reader and analyzes them in bulk; no
form ever crosses host->worker (the host sends only a source-file path).

Worker-side cljs analyzer execution. Mirrors the parse + reader-loop
that live in `skeptic.cljs.analyzer-driver`, with no Skeptic / Schema /
Malli dependency. The host-side source-file wrapper is rewired to issue a
worker RPC instead of running the cljs analyzer locally.

Wire payloads carry the source-file descriptor only; the cljs compiler state
never crosses the wire.

Shared worker classpath assembly. Entrypoints own project classpath discovery;
this namespace owns the Skeptic worker runtime entries required to launch
skeptic.worker.server on top of that project classpath.

Host-side nREPL client over the Nippy transport: connect to a worker port and
send it ops, returning each reply map. The nREPL client is built once at
connect time and reused by every ask. Pairs with skeptic.worker.server.

Host-side worker process lifecycle: spawn a JVM running skeptic.worker.server,
read the port handshake off its stdout, and tear it down. The caller passes
the already assembled Skeptic runtime classpath plus the project classpath
that the server installs as a separate context loader.

Worker-side project execution context.

The worker has a private runtime used to boot nREPL/Nippy/analyzers. Project
code is loaded and analyzed only while this context is active, so require,
macroexpansion, source reading, analyzer class lookup, predicate calls, and
declaration collection all see the same project class loader bindings.

Worker-side Nippy nREPL server. Runs in the spawned JVM on Skeptic's
private worker runtime and answers host requests on demand. Project classpath
entries are installed as a separate context loader around project-resolution
operations. Plan 2 Phase 1.5 adds the
handle-table machinery: every Class operand on the wire is an opaque handle
(integer for bootstrap-interned host-runtime classes; UUID-string for project
classes). Worker is sole owner of `Class/forName`, `.isAssignableFrom`,
`instance?`, and class equality.

Phase 5 adds the analyzer ops. The analyzer-execution glue lives
in `skeptic.worker.analyzer-clj` / `skeptic.worker.analyzer-cljs`. No other `skeptic.*`
namespace is required from this server: Skeptic's own analysis code and
Plumatic Schema / Malli stay on the host (B3/B4).

Length-prefixed Nippy transport for Skeptic's private nREPL worker link.

Host-safe wire-contract constants shared by both JVMs. Holds ONLY the keys
and accessors for values that cross the worker->host AST boundary; carries no
nREPL, tools.analyzer, or other worker-classpath dependency, so the host may
require it without re-coupling to worker-only code.

The non-EDN sentinel: a raw analyzer-AST `:val`/`:form`/`:raw-forms` leaf that
is not EDN-readable (regex Pattern, fn object, Var, Namespace) is shipped as
`{::nonedn true ::class <class-handle>}`. The host types it by its class via
the carried handle; it never inspects the original value.

Form metadata: the worker captures the host-read meta keys off each form into
a plain data vector in `clojure.walk/postwalk` order (`capture-form-meta`);
the host replays them onto the structurally-identical received form in the
same order (`apply-form-meta`). Shape is never altered, so structural form
walks survive.