Adds training-subsystem observability to INFO compression and
integration tests exercising the full training + retirement lifecycle.

Metrics (additive to the last_duration_ms / last_sample_count fields
wired by #39):
  compression_training_state          idle/scanning/submitted/cooldown
  compression_training_scans_started  total scans initiated
  compression_training_successes      successful dict promotions
  compression_training_failures       aborts + ZSTD errors
  compression_training_cooldown_until_ms
  compression_training_current_db
  compression_training_dicts_retired  dicts that completed lifecycle (GC'd)
  compression_training_debug_frame_refs  active retiring dict frame_refs

Integration tests (tests/integration/compression-training.tcl):
  - First-training trigger fires and produces a usable dict
  - After training, new writes get compressed
  - Training does NOT fire below min keys
  - Training aborts + cooldown on ineligible values
  - Training scans across multiple databases
  - Dict retirement: compress 20 keys -> decompression mode ->
    read all -> dict GC'd (asserts frame_refs == 20, the regression
    guard for the double-count fix in #42)

The retirement test is FLUSHALL-free: 200 training keys are SET before
the dict exists (stay RAW, no refs); only 20 keys SET after the dict
is active get compressed.

Depends on #42 (install-path double-count fix), now merged to unstable.

Adds training-subsystem observability to INFO compression and
integration tests exercising the full training + retirement lifecycle.

Metrics (additive to the last_duration_ms / last_sample_count fields
wired by #39):
  compression_training_state          idle/scanning/submitted/cooldown
  compression_training_scans_started  total scans initiated
  compression_training_successes      successful dict promotions
  compression_training_failures       aborts + ZSTD errors
  compression_training_cooldown_until_ms
  compression_training_current_db
  compression_training_dicts_retired  dicts that completed lifecycle (GC'd)
  compression_training_debug_frame_refs  active retiring dict frame_refs

Integration tests (tests/integration/compression-training.tcl):
  - First-training trigger fires and produces a usable dict
  - After training, new writes get compressed
  - Training does NOT fire below min keys
  - Training aborts + cooldown on ineligible values
  - Training scans across multiple databases
  - Dict retirement: compress 20 keys -> decompression mode ->
    read all -> dict GC'd (asserts frame_refs == 20, the regression
    guard for the double-count fix in #42)

The retirement test is FLUSHALL-free: 200 training keys are SET before
the dict exists (stay RAW, no refs); only 20 keys SET after the dict
is active get compressed.

Depends on #42 (install-path double-count fix), now merged to unstable.

PR #41 delivers the S2.13 COW audit (no violators) and the S6.1
merge-blocker test tests/unit/compression-cow-invariant.tcl. Record the
audit outcome, the external:skip rationale, and the separately-tracked
DEBUG DIGEST / getDecodedObject crash discovered during the audit
(Phase-B blocker, follow-up PR). Update the Phase-A override note to
reflect S4.x (#39) and S2.13 (#41) as done.

* test(compression): COW-invariant merge-blocker (S2.13)

Add tests/unit/compression-cow-invariant.tcl, the runtime form of the
R2.4.5 COW-audit checklist and a v1 merge blocker per design §7.2.

The feature relies on two correctness invariants when a value is, or is
being, compressed:

  (1) Decompress-before-mutate. lookupKey(...,LOOKUP_WRITE) permanently
      decompresses any OBJ_ENCODING_COMPRESSED value to RAW before the
      command handler runs, so no in-place byte-mutating command ever
      operates on a compressed frame (which would corrupt bytes or hit
      getDecodedObject()'s serverPanic — COMPRESSED is neither
      sdsEncodedObject nor INT).

  (2) Worker-snapshot immutability (R2.4.4). While a worker reads a
      value's sds bytes, the value is pinned (refcount>=2), so a
      concurrent in-place mutation COWs via dbUnshareStringValue,
      leaving the worker's bytes untouched.

Both are code-discipline, not type-enforced. The test exercises them at
runtime across every in-place string mutator (APPEND, SETRANGE, SETBIT,
BITFIELD SET, GETSET, GETDEL, SET-overwrite), a 200-iteration mutation
storm against the live worker pool, and a transient-view + write-path
interaction. Each asserts the result matches the value semantics
computed independently in Tcl, that compression_errors_total stays 0,
and that the mutated value re-compresses and round-trips.

The audit behind the test found no violators: t_string.c, bitops.c,
hyperloglog.c, module.c (DMA write / truncate / OpenKey), and debug.c
all honor the write-lookup decompress + dbUnshareStringValue discipline.

Auto-discovered via the tests/unit/*.tcl glob; skips cleanly under
BUILD_ZSTD=no (no gen-zstd-dict helper). Compression is reached via
COMPRESSION SWEEP FORCE (the deterministic operator trigger) rather than
async enqueue timing; startup raises compression-dict-max-versions and
flushes for --external shared-server headroom.

* test(compression): clean up shared-server state in COW-invariant test

The COW-invariant test enables compression (master=compression,
sweeper, an imported dict) and leaves compressed values in the
keyspace. In --external shared-server mode this pollutes the server
for every subsequent test file. The next file, unit/other, runs
DEBUG DIGEST, whose computeDatasetDigest -> xorObjectDigest ->
mixStringObjectDigest path iterates the kvstore directly and calls
getDecodedObject() on the leftover compressed value, hitting
serverPanic("Unknown encoding type") (object.c) -> server crash ->
the external CI jobs (test-external-{standalone,cluster,nodebug})
fail with "I/O error reading reply".

Add an end-of-file cleanup test that flushes the keyspace (dropping
all compressed frames) and turns the feature off, leaving the shared
server clean. dict-max-versions is left at 16 (not reset to the
default 4) so later suites that import dicts into the shared registry
have headroom.

This is test hygiene only. The underlying DEBUG DIGEST crash on
compressed values is a real, pre-existing product bug (a kvstore-
direct reader that does not decompress, the same class PR #24 fixed
for rdbSaveStringObject / AOF rewrite but missed for the digest
path). It is tracked separately and must be fixed before transparency
mode (full corpus under --compression) lands.

* test(compression): tag COW-invariant test external:skip

The previous cleanup-at-end approach did not fully solve the shared
external-server pollution: this test churns global compression state
and cannot restore a pristine registry (a dict that ever held frames
is not reliably reclaimable today, so it lingers). That broke
unit/type/compression's documented-defaults / clean-registry
assertions, which run after this file in --external mode.

Tag the file external:skip instead. The test deliberately reconfigures
the server globally (master switch, sweeper, imported dict, compressed
frames), which makes it a poor citizen on a shared, externally-managed
server. Its COW-correctness value is fully exercised in normal
(dedicated-server) mode, the primary CI mode, where the server is torn
down between files. This matches the precedent of other stateful tests
(dump, expire, introspection, ...).

Removes the now-unneeded end-of-file cleanup test.

* docs(plan): mark S2.13 (COW audit) + S6.1 (cow-invariant test) done

PR #41 delivers the S2.13 COW audit (no violators) and the S6.1
merge-blocker test tests/unit/compression-cow-invariant.tcl. Record the
audit outcome, the external:skip rationale, and the separately-tracked
DEBUG DIGEST / getDecodedObject crash discovered during the audit
(Phase-B blocker, follow-up PR). Update the Phase-A override note to
reflect S4.x (#39) and S2.13 (#41) as done.

* test(compression): fix stale comments after external:skip change

The startup and cow_configure comments still described running 'against
the same server as the integration suite in --external mode'. With the
file now tagged external:skip that's inaccurate — it runs only against a
fresh dedicated server. Reword to reflect that the startup flush + cap
headroom are defensive clean-slate setup, not shared-server handling.

* feat(S1/S4): training lifecycle metrics + integration tests

Adds training-subsystem observability to INFO compression and
integration tests exercising the full training + retirement lifecycle.

Metrics (additive to the last_duration_ms / last_sample_count fields
wired by #39):
  compression_training_state          idle/scanning/submitted/cooldown
  compression_training_scans_started  total scans initiated
  compression_training_successes      successful dict promotions
  compression_training_failures       aborts + ZSTD errors
  compression_training_cooldown_until_ms
  compression_training_current_db
  compression_training_dicts_retired  dicts that completed lifecycle (GC'd)
  compression_training_debug_frame_refs  active retiring dict frame_refs

Integration tests (tests/integration/compression-training.tcl):
  - First-training trigger fires and produces a usable dict
  - After training, new writes get compressed
  - Training does NOT fire below min keys
  - Training aborts + cooldown on ineligible values
  - Training scans across multiple databases
  - Dict retirement: compress 20 keys -> decompression mode ->
    read all -> dict GC'd (asserts frame_refs == 20, the regression
    guard for the double-count fix in #42)

The retirement test is FLUSHALL-free: 200 training keys are SET before
the dict exists (stay RAW, no refs); only 20 keys SET after the dict
is active get compressed.

Depends on #42 (install-path double-count fix), now merged to unstable.

* test(compression): simplify first-training dict assertions

The first-training test had a confusing assertion:
  assert {$dict_after != $dict_before || $dict_before > 0}
The '|| dict_before > 0' clause made it vacuously true whenever a
dict already existed — the opposite of the intent. It was leftover
from shared-server (external) handling, but the test is external:skip
and always runs on a fresh instance where dict_before == 0.

Replaced with a direct fresh-instance check (active_dict_id == 0
before, > 0 after). Also dropped an unused dict_before capture in the
'does NOT fire' test (only known_dicts is asserted there).

* test(compression): reorder training tests so trigger gates are real

The old order trained a dict in test 1, leaving an active dict for the
rest of the shared-instance block. That made the negative-trigger tests
(below-min, ineligible-abort) pass vacuously: with a dict already
active, first-training can never fire regardless of key count or
eligibility (the trigger is gated on !active).

Reordered so all no-active-dict checks run first, then training fires
once:

  1. Below min keys -> no trigger (asserts scans_started == 0)
  2. Enough keys but none eligible -> scan fires + aborts
     (scans_started == 1, failures == 1) — metric-driven, not timing
  3. First-training across db0+db1 -> dict promoted (merges the old
     multi-DB test; only one first-training can fire per active dict)
  4. After training -> new writes compressed
  5. Active dict blocks a new first-training (new test for the
     'no retrain while a dict is active' invariant)

Test 2 arms the 30s cooldown; test 3 uses a 60s wait_for_trained_dict
to absorb it. Negative tests now assert on scans_started / failures /
successes counters instead of sleeping and hoping.