feat(writer): pco E6 — IntMult mode (mode=1) with triple-GCD detection

Adds IntMult encoding mode to PcoEncodingEncoder. For integer dtypes,
samples the chunk, computes triple-GCDs over disjoint triples, applies
statistical filter (z-score > 3 vs. uniform-mod-GCD null), and verifies
> 0.5 bits/element savings before switching from Classic.

When chosen:
  mult[i] = latent[i] / base
  adj[i]  = latent[i] % base
Both streams encoded independently with bin DP + tANS; chunk meta
carries mode=1, base, primary bins, secondary bins. Wire format:
  page header: primary states (4), secondary states (4), align
  per batch:  primary ANS, primary offsets, secondary ANS, secondary offsets

Refactored single-stream Classic page encoding into a StreamData helper
shared between Classic and IntMult paths.

FloatMult/FloatQuant deferred — marginal gain over existing Classic+ALP
cascade, significant algorithmic complexity (approx pair-GCD, false
position root finder, trailing-zero detector).

Java→Rust integration test confirms wire format: values × 1000 in I64
column round-trips through Rust JNI decoder.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: dfa1

docs/adr/0007-pco-encode.md

@@ -1,6 +1,6 @@
 # ADR 0007: Pure-Java `vortex.pco` encoder
 
-- **Status:** Accepted (E0 gate cleared — E1 is next)
+- **Status:** Implemented (E1-E5, E7-E9 done; E6 partial: IntMult only; FloatMult/FloatQuant deferred as marginal vs. existing Classic+ALP cascade)
 - **Date:** 2026-06-13
 - **Deciders:** project maintainer
 - **Supersedes:** —

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

@@ -1454,6 +1454,23 @@ void javaWriter_rustReader_pco_i64_multiChunk(@TempDir Path tmp) throws IOExcept
         assertThat(decoded).containsExactly(data);
     }
 
+    @Test
+    void javaWriter_rustReader_pco_i64_intMult(@TempDir Path tmp) throws IOException {
+        // Given — values × 1000: triple-GCD detection picks base=1000 → mode=1
+        Path file = tmp.resolve("java_pco_i64_intmult.vtx");
+        long[] data = LongStream.range(0, 2000).map(i -> i * 1000L).toArray();
+        try (var ch = FileChannel.open(file, StandardOpenOption.CREATE, StandardOpenOption.WRITE);
+             var sut = VortexWriter.create(ch, TS_SCHEMA, WriteOptions.defaults(),
+                     List.of(new PcoEncodingEncoder()))) {
+            // When
+            sut.writeChunk(Map.of("ts", data));
+        }
+
+        // Then
+        long[] decoded = readLongColumn(file, "ts");
+        assertThat(decoded).containsExactly(data);
+    }
+
     static Stream<long[]> pcoSequentialI64ArrayProvider() {
         // Sequential arrays exercise the Consecutive delta path (stride-1 and stride-N)
         return Stream.of(