[mgravell]

Cache hits currently re-parse the retained RESP payload on every serve. For HybridCache-style consumers (and plain string/scalar traffic), the deserialized result is often provably safe to hand back as the same instance — this PR memoizes it on the cache entry.

Design

• Each cache entry gains one memo slot: an immutable (parser, value, bytes) atom, CAS'd in on a first-wins basis. There is no map and no lookup: a fetch is a single ReferenceEquals on the parser reference, so a different parser instance for the same entry simply re-parses (never a wrong result), and the slot never churns.

• The decision happens post-parse in the send funnel — no flag threads through RespReader or the context.

• The core auto-enrolls only provably-shareable results: string, and (where the runtime can detect it, #if NET) structs with no interior references via RuntimeHelpers.IsReferenceOrContainsReferences<T>(); down-level falls back to primitives and enums only.

• Richer rules are opt-in via a new public capability side-interface alongside IRespHandler<TResult>:

  public interface IRespResultReuse<TResult>
  {
      bool MayReuse(in TResult value); // per-value veto
      long SizeOf(in TResult value);   // estimate in bytes; 0 = uncounted
  }

  This is how an external layer (e.g. HybridCache) teaches its deserializing handler to share results under its own reuse rules.

Budget accounting

A memoized value charges MaxBytes when its size is known: the core sizes its own enrollments (24 + 2·len for strings, 16 + sizeof(T) for boxed no-ref structs), and opted-in handlers volunteer via SizeOf (0 = uncounted). The charge is paired with the memo atom itself: whoever takes the memo (eviction, replacement, slab compaction — which transfers ownership rather than copying) credits back exactly what was debited, and taking leaves a tombstone so a late setter racing a discard loses the CAS and charges nothing. The budget cannot drift, lock-free.

Scope cuts (documented in code)

• The fill-path parse is not memoized; the memo is created on the first hit, so one extra parse per entry lifetime.
• One memo slot per entry, first parser wins; later parsers for the same entry re-parse.

Tests

11 new tests in RespCacheResultReuseTests cover instance-reuse for strings and no-ref structs, non-enrollment of ref-bearing structs (RedisValue), handler opt-in/refusal per value, parser-instance guarding, memo death with the entry on local writes, and exact charge/credit of both core-sized and volunteered sizes. The 270-test cache/tracking sweep and all-TFM library build are clean.