perf(cache): Reduce allocations on the normalize, read, and SQLite paths

[AlexanderGH]

Summary

An allocation and complexity pass over the three hot paths of the normalized cache: normalizing a response (write), CacheBatchReader (read), and record serialization to/from SQLite. Everything here is behavior-preserving — no public API change, apiCheck passes with no dump regenerated.

The theme is work repeated per field per object. Several of these paths did something once per field of once per object in a list, where the result was either identical every time or reachable without building an intermediate collection at all.

Reviewers: Please review one commit at a time. Each commit message contains useful context about the smaller sets of changes.

Write path (Normalizer)

• Index selections by response name once per object. allFields.filter { it.responseName == entry.key } was a linear scan per response key, so normalizing an object was O(fields²). Fields are now indexed into a Map<String, List> as they're collected, which costs no more than the flat list it replaced.
• Stop rebuilding a field that is already its own merge result. newBuilder().selections(...).build() ran per field per object even when the merge group held a single element, where the rebuild produces a copy equal to the original.
• Memoize field keys. DefaultFieldKeyGenerator goes through CompiledField.nameWithArguments(variables), which allocates an okio Buffer + BufferedSinkJsonWriter per call (and argumentValues() allocates two ArrayLists even for a zero-argument field). A field with arguments inside a list of N objects encoded the same string N times. Keys are now memoized per parent type name, keyed on CompiledField identity.

The last two compose: memoization is only possible because the field instance is now stable across the objects of a list. Only the shared (non-rebuilt) fields are memoized — a merged field is a fresh instance per object, so caching its key would only retain the copy.

Read path (CacheBatchReader)

• Intern the response paths the data map is keyed by. Map<List, Any> fed by path + responseName / path + index meant every lookup hashed and compared a list as long as the field's depth, and replaceCacheKeys re-walked the tree rebuilding the same lists. Replaced with a ResponsePath tree (parent pointer + segment + lazily-created children map): appending a segment is a lookup on the parent, and keying a map on a path hashes an identity. Two paths are the same node iff they have the same segments, which is what lets identity stand in for structural equality. asList() remains only to fill in the path of cache-miss errors.
• Skip merge grouping when every field has its own response name, which is the common shape. Each field is then a group of one and already its own merge result, so grouping only allocated a Pair to hash it by, plus a builder and a selection list per field per object.
• firstError() no longer allocates an ArrayDeque per field to search a value that usually has no error.
• processErrors is no longer quadratic in fields per object: fieldSelection(key) re-flattened the whole selection set with filterIsInstance + flatMap on every call. The responseName → CompiledField map is built once per object. Only on the hasErrors path, where it dominated.

Max age

MaxAgeContext(fieldPath.map { it.toMaxAgeField() }) was built per field per object, and toMaxAgeField() recursively rebuilds a MaxAgeContext.Type tree for every interface the field's type implements. GlobalMaxAgeProvider ignores its context entirely, and DefaultMaxAgeProvider is one — so the whole tree was being built and discarded for everyone on the default configuration. An is GlobalMaxAgeProvider check hoisted to construction skips it, in both Normalizer and CacheControlCacheResolver.

Providers that do read the path are unaffected and still get the full context.

SQLite

• Stop boxing record bytes. recordBytes.asIterable().chunked(BLOB_CHUNK_SIZE) boxed every byte into a List and materialized all chunks before the first insert, and toByteArray() unboxed back. Now an index loop with copyOfRange. Note this only ever affected records above the 1 MiB chunk threshold — there was already a fast path below it — so this is a smaller win than the code shape suggests.
• Drop two copies per record read. buffer.write(row.record) → readByteArray() → deserialize re-wrapping in a third Buffer. deserialize now takes a BufferedSource.
• HashMap(size) on deserialize was sized so it rehashes at the 0.75 load factor; 0.until(size).map { } allocated an IntRange and iterator per list; shortenCacheKey/expandCacheKey called replaceFirst after an explicit startsWith, rescanning the prefix.

Elsewhere

• writeOperation called .values.toSet() before cache.merge. Record.hashCode() recursively hashes fields + metadata, so this walked the entire normalized response a second time — and the values of a cache-key-keyed map are already distinct. merge takes a Collection, and writeFragment already passed .values bare.
• MemoryCache.merge / SqlNormalizedCache.merge materialized every changed field key of every record into a throwaway list before the set (flatMap {}.toSet()). Now the one-pass buildSet shape already used by dependentKeys().
• Record.changedKeys allocated an intersection, two differences, a filter, a map and a set; now one pass. Record.withDates rebuilt an identical two-entry map per field.
• DefaultRecordMerger.merge double-looked-up each field and always called existing.metadata.mergedWith(incoming.metadata) — which copies — even when both were empty.

Correctness notes for reviewers

The one subtlety worth a close look: the Normalizer's rebuild does .condition(emptyList()), so a lone field is only reused when its condition is already empty. Reusing a field that has a condition would hand downstream consumers — a custom FieldKeyGenerator, MetadataGenerator, EmbeddedFieldsProvider, or CacheKeyGenerator — a field that differs from what they used to receive.

CacheBatchReader's rebuild does not clear the condition, so its singleton skip is unconditionally safe, and it falls back to the original groupBy when duplicate response names do exist, h preserves ordering exactly.