…rd in drain

Replaces the placeholder pass-through worker body with real
ZSTD_compress_usingCDict against the active dictionary, and replaces
the placeholder drain handler with the post-compression net-savings
guard (R2.4.3). The full install path (createCompressedObject +
dbOverwrite + compressionRegistryIncRef + caller-pin decRefCount)
remains stubbed — that lands with the write-path hook in S2.7 when
there's a real production caller emitting compression candidates.

Worker body (compression_workers.c):
  - Per-worker ZSTD_CCtx allocated once at thread start, reused for
    every job (CCtx is not thread-safe; one per worker keeps allocator
    pressure off the per-job hot path).
  - Atomically loads the active dict via compressionRegistryActive().
    Per the QSBR contract (§4.4) the pointer stays valid until the
    worker reports quiescent at end-of-iteration.
  - "compression-enabled yes but no active dict yet" state (R2.1.5)
    short-circuits to err=1 / dst=NULL — no allocation, no encode.
  - Compresses directly into a single zmalloc'd buffer at offset
    HEADER_SIZE; writes the header in-place after measuring the
    actual compressed size; shrinks via zrealloc to avoid leaking
    ZSTD_compressBound slack into used_memory (per design §5.2).
  - Preserves ZSTD error codes via signed downcast; positive err
    values are reserved for worker-policy decisions (no-dict, etc.).

Drain handler (compression_workers.c):
  - err != 0 || dst == NULL: dispose, no install.
  - dst_len >= uncompressed * (1 - savings_ratio_pct/100): net-savings
    guard rejects, dispose. INFO counter
    compression_skipped_incompressible++ comes in S4.1.
  - Otherwise: install path is S2.7 (placeholder dispose for now).

Test-only accessors (compression_workers.h + .c):
  - compressionWorkersDrainOutboxForTesting: peek without freeing.
  - compressionWorkersFreeJobForTesting: caller-side cleanup.
  - Field readers for compressionJob (file-private struct).
  Production code consumes jobs via compressionWorkersDrainOutbox.

New gtest cases (test_compression_workers.cpp):
  - RealCompressionRoundTrip: install synthetic dict, encode 1 KB
    of compressible JSON, decompress with same DDict, byte-equal.
  - NetSavingsGuardRejectsIncompressible: random bytes, drain through
    production handler, verify no crash on rejection path.
  - NoActiveDictMarksJobNotCompressed: enqueue without a dict, verify
    err != 0 and dst == NULL.
  - CompressionFromMultipleWorkersIsConsistent: 4 workers x 100 jobs,
    each compressed buffer round-trips correctly.

Synthetic dict helper (installSyntheticDict, test-private): generates
~100 KB of training corpus from a small JSON-shaped sample list,
runs ZDICT_trainFromBuffer, creates CDict/DDict, adds via
compressionRegistryAdd. ~100x dict-size of training data is the ZSTD-
recommended minimum.

Verified locally:
  - make -j2 -C src clean.
  - ./runtest --single unit/type/compression: 10/10 pass.
  - Server boots cleanly with --compression-enabled yes
    --compression-threads 2 (worker pool starts, awaits jobs).

Not verified locally (CI):
  - gtest unit tests (libgtest-dev not installed locally).
  - clang-format-18 (not installed locally).

Plan.md S2.5 marked complete.

Addresses the 5 review threads on PR #17.

T-3346992511 (plan.md L174): drop "(PR pending)" parenthetical from
the S2.5 sub-task. Eventually merged is the default state.

T-3347191182 (drain handler): add TODO(S4.1) markers at the three
drain-handler branches naming the exact counter contributions S4.1
will wire in. Per design R2.10.1 / R2.3.5:
  - err < 0 (real ZSTD error): compression_errors_total++ + rate-
    limited LL_WARNING per R6.1.
  - err > 0 (worker policy, no-dict): no counter — benign R2.1.5
    state, tracked via compression_state.
  - Net-savings reject: compression_skipped_incompressible++ AND
    fold the actual measured ratio into compression_live_ratio_10m
    (rejection ratios in [0.9, 1.05] inflate the EMA and naturally
    trip the drift threshold per R2.3.5).
  - Successful install (S2.7+): compressions_per_sec rate update +
    fold success ratio into the EMA.
Also added a TODO(S2.7) marker spelling out the install steps that
land with the write-path hook.

T-3347060548 (test seam in public header): refactor to match the
established Valkey convention (see quicklist.c / intset.c testOnly*
functions).
  - Renamed compressionWorkers*ForTesting → testOnlyCompressionWorkers*.
  - Removed the entire test-only block from compression_workers.h
    (~36 lines deleted). Production-callable surface now contains
    no test seams.
  - Definitions live only in compression_workers.c; the gtest test
    file declares what it needs locally in its own extern "C" block.
  - Replaced the 5 field accessors with a single
    testOnlyCompressionWorkersJobRead that fills caller-provided
    out-pointers. The result-projection struct (CompressionJobView)
    is defined in the gtest test file; production code carries no
    record of the projection layout.

T-3347222201 (callout for @GilboaAWS): no code change; informational
note about the synthetic-dict helper being portable to S1.x training
tests.

T-3347268445 (test:587 reject-path comment): prefixed the existing
"comes in S4.1" comment with TODO(S4.1) so grep can find it when
S4.1 wires the rejection counter.

Convention adopted: TODO(<step-id>) comments mark code that
intentionally defers behaviour to a future implementation step.
Grep-friendly, ties deferred work to a specific plan step. Documented
in SESSION_CHECKPOINT.md (working artifact).

Verified locally:
  - make -j2 -C src clean.
  - ./runtest --single unit/type/compression: 10/10 pass.
  - No remaining ForTesting symbols anywhere in src/.

Plan.md S2.5 line tightened.