`CtxWrap` leaks the C++ ObjectWrap implementation detail — as far as
the JS API is concerned, the object IS the thread context. Rename:

- The JS-visible class name (SetClassName) and the addon export
  property name: "CtxWrap" -> "ThreadContext".
- The prototype's append method: "append" -> "appendAttributes" for
  parity with the top-level helper's phrasing.

Error messages updated accordingly. The native C++ class itself
keeps the `CtxWrap` identifier — that's the conventional
ObjectWrap-style naming on the C++ side and isn't user-visible.

Public JS API surface (runWithContext / enterWithContext /
appendAttributes / ...) is unchanged in this commit; just internal
identifiers move.

Pure stylistic cleanup ahead of the API redesign so the redesign diff
stays focused on semantics:

- add 'use strict' pragma
- single-quote string literals
- drop redundant '= undefined' on let declarations
- inline single-statement if-return blocks
- collapse blank lines inside asyncContextFrameError
- replace 'x == null' with explicit '=== null || === undefined'

Reshape the top-level surface so consumers can cache one record per
logical scope and re-install it without allocation churn:

- ThreadContext is now a JS-constructable class:
  `new threadContext.ThreadContext(traceId, spanId, attrs?)`. Instance
  methods are `appendAttributes(attrs)` and `isTruncated()`, plus the
  debug-only `debugBytes()`.
- New top-level operations take a context handle (or undefined):
  `getContext()`, `setContext(context)`,
  `runWithContext(context, fn)`. JS reference identity replaces any
  byte-level comparison for "is this context already active".
- Drop the opts-form top-level helpers (`enterWithContext(opts)`,
  `appendAttributes(attrs)`, `clearContext()`, `isContextTruncated()`)
  in favor of:
    setContext(new ThreadContext(...))
    context.appendAttributes(...)
    setContext(undefined)
    getContext()?.isTruncated() ?? false
- NamedContext is now a thin factory: `buildContext(opts)` resolves
  `namedAttributes` to a positional array and returns a
  ThreadContext; `runWithContext` / `enterWithContext` /
  `clearContext` are kept as one-liner sugar that compose with the
  top-level functions.

Tests updated to match the new shape; the few tests that exercised
removed guards (TypeError on undefined opts, "no active thread
context" thrown by the removed top-level appendAttributes, etc.) are
rewritten or dropped — those error paths don't exist anymore.

Four independently-flagged concerns, ported from the equivalent fixes on
the pprof-nodejs vendored copy (DataDog/pprof-nodejs#366):

- Accept optional third `attributes` arg in ThreadContext constructor.
  The TS ThreadContextCtor.new type declares `attributes` optional, but the
  C++ side hard-errored on `args.Length() != 3`. Loosen to accept 2 or 3
  args; EncodeAttrs already handled undefined/null attrs_val correctly.

- Fold `cleanup_registered` into `undefined_addr`. Uses the field's zero /
  non-zero state as the 'already-registered' flag: it starts at zero,
  ResetDiscoveryStruct clears it back to zero (so a re-init on the same
  thread would re-register), and any real V8 undefined singleton address is
  non-zero. Removes the separate thread_local static.

- Coerce attribute values to strings in a pre-pass in EncodeAttrs before
  writing to the output buffer. Value->ToString may execute user JS (custom
  toString methods) which could re-enter into the ThreadContext via
  appendAttributes and interleave with our writes. Separating the coerce
  phase from the encode phase keeps the encode phase re-entrancy-free.

- Make the 'enterWithContext attaches the record to the current async
  scope' test callback `async` and `await tcRun(...)`. Previously the
  callback returned a promise via `tcRun(...)` and the promise's inner
  `.then` assertion could fire an unhandled rejection instead of a test
  failure.