perf: widen AVX2 percentile scan to 16 int64/iter (vector accumulator)

[fcostaoliveira]

Summary

Widen the AVX2 percentile scan (get_value_from_idx_up_to_count_avx2, added in #134) from
4 → 16 int64 per iteration using a vector accumulator.

The current loop processes 4 counts per iteration and, every iteration, does a horizontal
reduction plus two _mm_extract_epi64 (vector→GPR moves) plus the running-total early-exit
branch. Those are the expensive parts. This PR accumulates 16 counts per iteration (4×256-bit
loads summed in a __m256i) and reduces to a scalar block sum once per 16 elements, so the
GPR extracts and the branch run 4× less often. The four loads and three vpaddq pipeline on
the load/ALU ports.

Only the block granularity changes:

• the scalar fallback (#ifndef HDR_HAS_AVX2_DISPATCH) is untouched;
• the uint64_t chunk-sum overflow hardening is preserved;
• the per-element fine walk (taken only for the single block that crosses the target) and the
  scalar remainder tail are unchanged;
• results are bit-identical to the previous scan.

Benchmark

test/hdr_percentile_bench — hdr_value_at_percentile throughput, best of 20 runs after 3
warmups, pinned to one core, measured base vs patch back-to-back in the same session on an
Intel Xeon Gold 6248 (Cascade Lake):

Compiler	Base (main)	This PR	Δ
gcc 11.4	0.16 M q/s	0.38 M q/s	+137%
clang 14.0	0.18 M q/s	0.44 M q/s	+144%

The benchmark's sink accumulator is byte-identical between base and patch on both compilers
(17401860284404480), i.e. every percentile query returns exactly the same value as before.

Steps to reproduce

# base (main) and patch, each:
cmake -S . -B build -DCMAKE_BUILD_TYPE=RelWithDebInfo \
  -DHDR_HISTOGRAM_BUILD_PROGRAMS=ON -DHDR_HISTOGRAM_BUILD_BENCHMARK=ON
cmake --build build -j
taskset -c 8 ./build/test/hdr_percentile_bench     # compare M queries/sec + sink

Correctness

• ctest green (gcc and clang).
• ASan + UBSan clean; the 16-wide loop only runs for idx < (counts_len & ~15), so the widest
  load counts[idx..idx+15] stays in bounds; the remainder is handled by the existing scalar tail.
• Identical hdr_value_at_percentile output verified via the byte-identical benchmark sink above.

Relationship to #137

This optimizes the existing (#134) AVX2 path and is independent of #137. If you prefer #137's
portable scalar block-sum (dropping the AVX2 dispatch), I'm happy to re-target — I can send the
same 16-wide vector-accumulator idea rebased on that, or the equivalent widening of the portable
block loop. Whichever direction you'd like, just say the word. Note #137 also restores the
normalizing_index_offset-aware fallback for decoded histograms; that behavior is orthogonal to
this change (this PR does not alter the direct-counts[] read introduced in #134).

[fcostaoliveira]

⚠️ Conflict heads-up: this enhances the AVX2 percentile scan, whereas my open #137 proposes to remove the AVX2 dispatch entirely (portable scalar block-sum). #138/#139 and #137 are two directions for the same read path — they conflict. Flagging for coordination; happy to pick one.