perf(data): absolute-space pyramid so acquire() is O(produced), not O(window)

Frame cost was O(capacity x levels) once the ring saturated: acquire() saw the
window base move (it always moves once the ring wraps), cleared the pyramid and
re-appended all 1,048,576 retained samples, and append() walked every live level
with no early stop -- 13,647,936 bucket merges and 73.8 ms per frame at a
1M-sample window, scaling with the window, which is what capped the 1 MS/s demo
at 32-58 ms/frame while it was still filling.

Index the pyramid in absolute bucket space instead. Level l bucket k covers the
samples [k * (kBucket << l), (k + 1) * (kBucket << l)), so a bucket's span never
depends on where the window starts and the window can slide over the aggregate
instead of forcing it to be rebuilt. Each level keeps its complete buckets in a
deque plus the absolute base of its first entry; append() folds a sample into the
single in-progress level-0 bucket and, only when that bucket completes, cascades
upward, stopping at the first level that gains no new entry; a new drop_before()
slides the window by discarding leading buckets and remembers where the window
begins. acquire() is now: drop to the new base, then append exactly what was
produced -- 256 merges and 0.034 ms per frame for 8192 new samples, independent
of the window, and memory bounded by the window (32,767 entries after 50M samples
through a 1M ring, the same as after 10M). A producer that laps the consumer by
more than capacity() between two acquires restarts the window rather than
splicing a gap.

Interface: `level(l) -> std::span<const MinMax>` cannot survive a ring and is
replaced by level_base/level_size/bucket in absolute bucket coordinates, plus
window_base/window_end/drop_before. The *_buckets queries stay in window
coordinates (index 0 = oldest retained sample), so Series keeps its window
semantics for callers; its exactness split now aligns in absolute space
(window_base() + the ceil/floor) because the bucket grid is absolute. The sums
move from per-level prefix sums to per-bucket ones -- the only representation a
sliding front can keep exact -- and StreamSeries::y_bounds() becomes
reduce(0, size()), exact in O(log n + kBucket) per frame instead of a scan of the
window. The pyramid owns the published window now, so there is no second copy of
base/end to keep in step, and gather() emits only buckets that are both complete
and wholly retained.

Tests: test-only merge counters (mirroring PLOT_PYRAMID_COUNT_COVERS, absent from
every non-test build) pin an acquire proportional to production and independent
of capacity, an append cost amortised over 16 live levels, and bounded memory;
brute-force checks pin absolute bucket aggregates across slides, sliding-window
reduce/sum/sumsq over unaligned ranges, and the level-1 gather mapping. The demo
now draws 946 samples/px at 1.03 ms/frame (967 fps) where the saturated window
cost 54.96 ms/frame (18 fps).

include/plot/data/detail/merge_count.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+#ifdef PLOT_PYRAMID_COUNT_MERGES
+
+#include <atomic>
+
+#include <plot/core/types.hpp>
+
+namespace plot::data::detail {
+
+/// Test-only instrumentation. Counts the bucket merges the append path has
+/// performed since the counter was last reset: one for the bucket pushed at
+/// level 0 when it completes, plus one for every parent bucket written above it.
+///
+/// The append path's *cost* is invisible in every answer -- a pyramid that walks
+/// every live level per sample returns exactly the same min/max/sum as one that
+/// stops at the first level that gained no entry -- so a test that wants to pin
+/// "amortised O(1) per sample, independent of the number of live levels" has to
+/// count merges. The counter exists only when PLOT_PYRAMID_COUNT_MERGES is
+/// defined (the test build defines it), so every normal build carries no counter
+/// and no increment on the append path.
+///
+/// Not part of the query surface and not meant for production use.
+inline std::atomic<u64>& merge_count() {
+  static std::atomic<u64> count{0};
+  return count;
+}
+
+}  // namespace plot::data::detail
+
+#endif  // PLOT_PYRAMID_COUNT_MERGES