fix(writer): train ALP-RD dictionary on a stratified sample

ALP-RD built its left-parts dictionary from the first SAMPLE_SIZE physical rows
(findBestDictionaryF64/F32 iterated values[0..sampleLen)). The cascade measures
ALP-RD's cost on its own stratified sample, so a head-only dictionary could look
cheap in the competition yet flood the tail with exceptions on the full re-encode
when the leading rows are unrepresentative (sorted or clustered floats) — a size
regression newly reachable now that ALP-RD is a top-level cascade candidate (#304
review). Train on a stratified sample spanning the whole array instead, matching
AlpEncodingEncoder.findExponentsF64.

Also harden AlpRdCascadeSelectionIntegrationTest: besides asserting the categorical
ALP-RD win (decided on a 4096-row sample), assert the file compresses below raw F64,
so the test can't pass on a degenerate "selected but didn't beat raw" outcome.

nyc-311 unchanged at 1644.25 MB (its leading rows were already representative);
408 round-trip property tests, 16 ALP-RD unit tests, and 217 interop tests pass;
full verify green.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: dfa1

integration/src/test/java/io/github/dfa1/vortex/integration/AlpRdCascadeSelectionIntegrationTest.java

@@ -15,6 +15,7 @@
 
 import java.io.IOException;
 import java.nio.channels.FileChannel;
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.StandardOpenOption;
 import java.util.List;
@@ -58,6 +59,13 @@ void highPrecisionF64_selectsAlpRd_andRoundTrips(@TempDir Path tmp) throws IOExc
                     .contains("vortex.alprd");
         }
 
+        // And it delivers real compression — the file is well below raw F64 (the pre-#304 fallback
+        // stored these columns as raw vortex.primitive). This guards a degenerate "selected but did
+        // not actually beat raw" win, independent of which encoding categorically won the sample.
+        assertThat(Files.size(file))
+                .as("ALP-RD compresses the high-precision column below raw F64")
+                .isLessThan(rows * (long) Double.BYTES);
+
         // And every value round-trips exactly.
         try (var vf = VortexReader.open(file, ReadRegistry.loadAll())) {
             double[] got = new double[rows];

writer/src/main/java/io/github/dfa1/vortex/writer/encode/AlpRdEncodingEncoder.java

@@ -49,7 +49,17 @@ private static EncodeResult encodeF64(double[] values, EncodeContext ctx) {
         }
 
         int sampleLen = Math.min(SAMPLE_SIZE, n);
-        Dictionary64 best = findBestDictionaryF64(values, sampleLen);
+        // Train the dictionary on a stratified sample spanning the whole array, not the first
+        // `sampleLen` rows. The cascade measures ALP-RD's cost on its own stratified sample, so a
+        // head-only dictionary here can look cheap in the competition yet flood the tail with
+        // exceptions on the full re-encode when the leading rows are unrepresentative (sorted or
+        // clustered floats). Mirrors AlpEncodingEncoder.findExponentsF64 (#304 review).
+        double[] sample = new double[sampleLen];
+        long stride = Math.max(1L, (long) n / sampleLen);
+        for (int i = 0; i < sampleLen; i++) {
+            sample[i] = values[(int) Math.min(i * stride, (long) n - 1)];
+        }
+        Dictionary64 best = findBestDictionaryF64(sample, sampleLen);
 
         Map<Short, Short> lookup = buildLookup(best.dict);
         long rightMask = -1L >>> (64 - best.rightBitWidth);
@@ -128,7 +138,14 @@ private static EncodeResult encodeF32(float[] values, EncodeContext ctx) {
         }
 
         int sampleLen = Math.min(SAMPLE_SIZE, n);
-        Dictionary32 best = findBestDictionaryF32(values, sampleLen);
+        // Stratified sample across the whole array (see encodeF64): a head-only dictionary can be
+        // measured cheap by the cascade yet explode on the tail during the full re-encode.
+        float[] sample = new float[sampleLen];
+        long stride = Math.max(1L, (long) n / sampleLen);
+        for (int i = 0; i < sampleLen; i++) {
+            sample[i] = values[(int) Math.min(i * stride, (long) n - 1)];
+        }
+        Dictionary32 best = findBestDictionaryF32(sample, sampleLen);
 
         Map<Short, Short> lookup = buildLookup(best.dict);
         int rightMask = -1 >>> (32 - best.rightBitWidth);