Externalize size cache: remove __buffa_cached_size from generated structs

[iainmcgin]

Closes #14.

Summary

Removes the in-struct __buffa_cached_size: CachedSize (AtomicU32) field from all generated owned and view types by threading an external SizeCache through the two-pass encode protocol.

Before

fn compute_size(&self) -> u32;       // stores into self.__buffa_cached_size via interior mutability
fn write_to(&self, buf);             // reads self.__buffa_cached_size
fn cached_size(&self) -> u32;

After

fn compute_size(&self, cache: &mut SizeCache) -> u32;   // pre-order reserve/set
fn write_to(&self, cache: &mut SizeCache, buf);         // pre-order consume
fn encoded_len(&self) -> u32;                            // provided: compute_size(&mut SizeCache::new())

encode(), encode_length_delimited(), encode_to_vec(), encode_to_bytes() construct a SizeCache internally — no caller-visible change for the common path. A new encode_with_cache(&self, &mut SizeCache, buf) provided method lets hot loops reuse a single cache (and its spill capacity) across many encodes.

Why

• Generated structs contain only proto fields (+ __buffa_unknown_fields). Exhaustive struct destructuring works; struct literals don't need ..Default::default() for the cache.
• No interior mutability. Send/Sync are structural instead of via AtomicU32 + Relaxed. &Message is genuinely read-only.
• Smaller structs. 4 bytes (+ padding) per message and per nested sub-message gone.

SizeCache

buffa::SizeCache is a pre-order slot table: compute_size calls reserve() before recursing into each LEN-delimited sub-message and set() after; write_to calls consume_next() in the same pre-order. Groups (tag-delimited) thread the cache without reserving. Map compute and write iterate for (k, v) in &map identically, so slot order is correct by construction (no reliance on .values()/.iter() ordering agreement).

Storage is [u32; 16] inline + Vec<u32> spill, so SizeCache::new() is allocation-free for messages with ≤16 nested LEN sub-messages — which covers every benchmark dataset except analytics_event.

Performance

vs main (criterion, this host's noise floor ~±10% per the JSON-encode control):

dataset	encode	encode_view	build+encode	build+encode_view
api_response	−7.5%	+2.7%	−1.1%	−0.2%
log_record	−1.0%	+0.2%	−4.1%	−3.7%
analytics_event¹	+7.8%	+7.6%	+1.3%	−1.0%
google_message1	−4.7%	−8.5%	−4.9%	−4.0%
media_frame	0.0%	0.0%	−7.4%	−2.6%

¹ spills past the 16-slot inline cache; build+encode (the realistic construct→encode→drop path) is within noise.

The earlier Vec-only SizeCache regressed small-message encode by 16–28% (per-call heap allocation); the inline-storage hybrid recovers that to parity-or-better. compute_size itself with a reused cache is at parity.

Scope

Applies to both Message and ViewEncode — view structs also lose __buffa_cached_size (reversing the field addition from #55, which had not yet shipped in a release). MessageField/MessageFieldView forwarders, the map-write path (no longer recomputes value sizes during write), clear() codegen, and all hand-written test impls updated.

Breaking change

Yes — compute_size/write_to signatures change and cached_size() is removed on both traits. Targeted for v0.4.0 alongside the __buffa:: namespacing and DefaultInstance/DefaultViewInstance safety changes.

Migration

For typical users (calling encode*()): no change.

For hand-written Message/ViewEncode impls or callers of compute_size/write_to directly:

• msg.compute_size() → msg.encoded_len() (if you only want the size)
• msg.compute_size(); msg.write_to(buf) → msg.encode(buf) (or thread a SizeCache explicitly if reusing across calls)
• Drop the __buffa_cached_size field and cached_size() method from hand-written impls.