When LANGSMITH_PERF_OPTIMIZATION=true, the flush-time
serializePayloadForTracing() call moves to a Node worker_threads worker,
removing main-thread event-loop blocking for large (base64-image-heavy)
payloads. postMessage transfers the payload via V8's structured clone,
which refcounts large strings across isolates -- about 3x cheaper than
stringifying on the main thread.

Falls back to synchronous serialize when: the flag is off, in
manualFlushMode, worker_threads is unavailable (browsers / edge /
Deno / etc.), or the payload contains non-cloneable values
(DataCloneError).

Tracks in-flight drain promises so awaitPendingTraceBatches waits for
the async serialize chain to register with batchIngestCaller.queue
before checking idleness -- otherwise tests using the callback-based
flush timing can race and see 0 fetches.

Benchmark (100 createRun, 2.5MB each, 500KB base64 image per message):
  DEFAULT mode:
    createRun p95       4.94ms
    wall time        1169ms
    event loop lag    824ms
  PERF mode (worker):
    createRun p95       0.51ms   (9.7x)
    wall time         583ms   (2.0x)
    event loop lag    161ms   (5.1x)

Tests: 30 existing serialize tests pass; 5 new SerializeWorker tests
cover plain object, well-known types (Date/Map/Set/RegExp/bigint),
DataCloneError, large base64, and circular refs. batch_client.test.ts
failures unchanged (same 8 pre-existing hideMetadata failures on main).

The worker-thread serialization path only pays for itself on payloads
dominated by large strings (base64 media, long documents) where V8 can
refcount string storage across isolates instead of copying. For
structure-heavy payloads -- many keys, deep nesting, lots of small
strings -- the structuredClone walk plus thread-hop overhead exceeds
the JSON.stringify cost and produced measurable regressions.

Add a short-circuiting, node-budgeted `hasLargeString` walk and gate
the worker dispatch on it. Falls through to sync serialize when no
large string is found. Also extend `estimateSerializedSize` to return
the longest-string length seen during its existing walk so future
callers can use the signal without an extra scan.

End-to-end bench (100 createRun+updateRun, mean of 3 runs):
  base64 (2.5MB images): 2.1x wall / 10x createRun p95 -- preserved
  structure (165KB nested): ~parity
  wide (192KB / 10k keys): ~parity
  mixed (60KB LLM): ~parity
  tiny (<1KB): ~parity

Mirrors the pattern used by prompt_cache / utils/fs: a Node-only
`worker_threads.ts` module re-exports the bits we use (`Worker`,
`WORKER_THREADS_AVAILABLE`) and is swapped for `worker_threads.browser.ts`
(returning `null` / `false`) via the package.json `browser` field.

Replaces the previous runtime detection (typeof require check + dynamic
import("node:worker_threads")) which relied on bundlers to externalize
the `node:` specifier. The new pattern is static and bundler-friendly:
browser / edge builds pick the stub at bundle time and never traverse
the Node variant at all.