feat(asap-precompute-rs): runtime port + sketch wrappers + cross-language parity (Phase 3 step 2)

[zzylol]

Summary

Three pieces of work in one commit:

1. Runtime port (Rust mirror of asap-precompute-go) — replaces every
   unimplemented!() stub left by Phase 3 step 1 (PR feat(asap-precompute-rs): bootstrap (Phase 3 step 1) #241). Translation,
   not redesign.
2. Real sketch wrappers in asap-precompute-rs/src/sketches/ over
   asap_sketchlib's wire-format-aligned types — mirrors
   asap-precompute-go/sketches/.
3. Cross-language byte-parity harness — Go-generated golden fixtures
   in integration/parity/golden/, Rust tests in
   asap-precompute-rs/tests/cross_language_parity.rs. Honest results:
   bytes diverge for every sketch today; 5 tests #[ignore] with
   documented reasons.

Naming cleanup: rename "state machine" → "runtime" everywhere
(matches asap-precompute-go's package-doc: "host-neutral edge
precompute runtime"). Branch name kept as-is.

ADR-0002 fix: §"Performance contract" Rust bullet rewritten to drop
"bit-identical to today's per-accumulator apply_proto_delta_bytes"
language; new phrasing pins the contract to mirroring
asap-precompute-go's runtime.

Port table

Rust file	Go reference
src/window.rs	asap-precompute-go/window.go
src/snapshot_cache.rs	asap-precompute-go/snapshot_cache.go
src/precompute.rs::PrecomputeImpl::{observe, observe_envelope, tick, drain}	asap-precompute-go/precompute.go
src/sketches/{ddsketch,kll,hll,countsketch,cms}.rs	asap-precompute-go/sketches/{ddsketch,kll,hll,countsketch,cms}.go

Trait surface

The Sketch trait gains one method: as_any_mut(&mut self) -> &mut dyn Any,
implemented by every wrapper as { self }. This unblocks paired
SketchObserver impls that need to call concrete-type methods like
update(f64) after the runtime hands them a &mut dyn Sketch. The
FakeSketch test double in tests/runtime.rs adds the same
{ self } impl; no other downstream changes.

Sketch wrapper status

Each wrapper:

• Constructor: pub fn new(params...) -> Self
• Implements Sketch (snapshot, compute_delta_against, apply_delta, merge, reset)
• Implements the appropriate sub-trait (QuantileSketch::quantile,
  CardinalitySketch::estimate_cardinality,
  FrequencySketch::estimate_count + top_k)
• Snapshot uses prost::Message::encode on a SketchEnvelope with
  the inner state proto (DdSketchState / KllState /
  HyperLogLogState / CountSketchState / CountMinState).
• KLL takes a deterministic seed via KLL::init_kll_with_seed.

compute_delta_against is pinned to is_full = true for every
wrapper. asap_sketchlib does not currently expose
ComputeDelta helpers (Go's sketchlib-go does:
ddsketch.ComputeDelta, hll.ComputeRegisterDelta,
countsketch.ComputeDelta, cms.ComputeDelta). Until those land
upstream, the wrapper emits ProtoFull envelopes every window —
correct but bandwidth-inefficient versus Go.

Cross-language byte-parity findings

All five #[ignore] tests fail honestly when run with
--include-ignored. Documented per-sketch reasons:

• DDSketch: asap_sketchlib::DdSketch's bucket-store layout
  (Vec<u64>, auto-grown in chunks of 128) emits trailing zeros
  in store_counts that sketchlib-go doesn't. Need either
  store-growth alignment or a normalization helper.
• KLL: the wrapper's KllState.items field is built from a
  copy-on-update history vec, not the compactor's
  items[]+levels[] view. asap_sketchlib::KLL doesn't expose
  levels() / items() accessors.
• HLL: asap_sketchlib::HllSketch::update hashes input
  differently from sketchlib-go::HyperLogLog::Update (different
  hash seed paths). Registers populated by 50 sequential bytes
  diverge register-for-register.
• CountSketch: asap_sketchlib::CountSketch::update uses
  twox_hash::XxHash64::oneshot(r as u64, key), while
  sketchlib-go::CountSketch routes through DeriveIndex /
  DeriveSign. Matrix populated cell-for-cell differently.
• CMS: same hashing-divergence pattern as CountSketch.

asap_sketchlib API gaps surfaced — needed for Go-parity:

• DdSketch::serialize_portable() -> Vec<u8> (full envelope)
• compute_delta(prev: &DdSketch, current: &DdSketch, threshold: u64) -> Vec<u8> for DDSketch / CMS / CountSketch / HLL
• KLL::levels() -> &[u32] + KLL::items() -> &[f64] accessors so
  the wire-format KllState can be built faithfully
• Hash-layer compatibility shim (xxh3_64 with sketchlib-go's
  CanonicalHashSeed table) for HLL / CountSketch / CMS

These are flagged inline in each wrapper's compute_delta_against
comment and in the cross-parity test ignore strings. Closing them
is a separate follow-up that touches asap_sketchlib upstream.

Tests (88 total)

• 43 lib unit tests (config / matchers / window / snapshot_cache /
  precompute / sketches::{ddsketch,kll,hll,countsketch,cms})
• 11 api_surface tests
• 27 runtime integration tests (22 fake-sketch + 5 real-sketch)
• 7 cross-language parity tests (2 sanity + 5 ignored byte-parity)
• 0 ignored except the 5 documented byte-parity gaps

Go side: integration/parity/golden_test.go is deterministic across
runs (single-series-per-sketch construction); existing
TestParity_AllSketches still passes.

Validation

• cd asap-precompute-rs && cargo build — clean
• cargo test — 88 tests pass (5 honestly-ignored byte-parity)
• cargo clippy --all-targets -- -D warnings — clean
• cargo fmt --check — clean
• cd integration/parity && go test ./... — pass (existing
  parity harness + new golden generator)
• cd asap-precompute-go && go test ./... — pass

🤖 Generated with Claude Code