Querier: remove redundant chunk data copy in ingester streaming select

[sandy2008]

What this PR does:

Removes the detachChunksFromBuffer copy that #7670 (unreleased) added to the querier's ingester streaming-select path. The chunk copy is redundant: chunk data never aliases the gRPC receive buffer, because Recv() allocates a fresh QueryStreamResponse per message, TimeSeriesChunk.Unmarshal appends a zero Chunk value, and Chunk.Unmarshal's m.Data = append(m.Data[:0], ...) therefore starts from a nil slice and allocates a private backing array. The copy cost one allocation + memcpy per chunk and kept the original and the copy simultaneously reachable across the streamingSelect loop, raising peak heap — the opposite of #7670's goal.

The label copy (FromLabelAdaptersToLabelsWithCopy) is unchanged and still required: LabelAdapter.Unmarshal uses yoloString, so label names/values genuinely alias the receive buffer.

The issue asked maintainers to confirm no code path constructs client.Chunk values that alias a shared or pooled buffer before removing the copy. That verification is part of this PR:

• Cortex registers a custom codec (pkg/cortexpb/codec.go, encoding.RegisterCodecV2) built on grpc-go's pooled mem.BufferSlice machinery — but pooling only affects where the wire bytes live. Decoding still dispatches (via the protobuf-v2 legacy shim) to the gogo-generated Unmarshal, which copies []byte fields unconditionally. QueryStreamResponse does not implement ReleasableMessage, so the codec never returns its buffer to a pool while decoded messages are live.
• A repo-wide search (codec registrations/overrides, sync.Pools, vtprotobuf, unsafe, every client.Chunk{...} construction site) found no producer whose Data aliases shared memory on the read path.
• Two tests pin the invariant so a future pooled or zero-copy decoder fails loudly: a direct gogo marshal→unmarshal round trip asserting chunk data does not overlap the wire buffer while a label value does (with a wire-buffer mutation cross-check that validates the test methodology itself), and the same invariant through the actually-registered codec with a payload above the gRPC buffer-pooling threshold (with a self-check that it stays above it).
• The call-site comment documents the assumption the removal relies on (response messages are never reused across Recv calls) and that a detach copy must be reinstated if QueryStreamResponse ever becomes pooled.

The #7670 benchmark constructed its input by hand-slicing one shared buffer into all chunks — a shape a real gRPC unmarshal never produces, which is why the copy had appeared profitable. It is rebuilt with independently allocated chunk data; on that input, dropping the copy saves ~107 KB and 200 allocations per 100-series response batch (1002 vs 1202 allocs/op; 168 KB vs 275 KB/op — allocation numbers are the meaningful signal, time-per-op is noise-dominated at this size).

Also noticed while verifying, deliberately not touched here: detachSeriesFromBuffer in pkg/querier/blocks_store_queryable.go (added by #7519, store-gateway path, vendored Thanos storepb types) has a similar shape and may warrant the same analysis separately.

Which issue(s) this PR fixes:
Fixes #7732

Checklist

• Tests updated
• Documentation added (n/a — no config or flag changes)
• CHANGELOG.md updated - the order of entries should be [CHANGE], [FEATURE], [ENHANCEMENT], [BUGFIX] (the unreleased Detach ingester series from gRPC buffers to reduce heap #7670 entry is amended to describe the final behavior)
• docs/configuration/v1-guarantees.md updated if this PR introduces experimental flags (n/a)

---

Per the Generative AI Contribution Policy: this change was developed with substantial AI assistance (multiple independent AI implementations reconciled and then adversarially cross-reviewed, under my direction). I have reviewed and validated all of it and take responsibility for its correctness.