refactor(writer): model Estimate as a three-state enum

Estimate's two variants were stateless empty records behind a sealed
interface, with paired SKIP/skip() and ALWAYS_USE/alwaysUse() singletons
(a Sonar S1845 case-only name clash) and a null sentinel for "no verdict".
Collapse to a plain enum { SKIP, ALWAYS_USE, COMPLETE }: COMPLETE replaces
null (defer to the full sample-encode evaluation), the clash disappears,
and callers switch from instanceof to ==.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: dfa1

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

@@ -163,8 +163,8 @@ private EncodeResult encodeWithCtx(DType dtype, Object data, EncodeContext ctx)
 
         // Stats-first selection (Rust vortex-compressor pattern): merge every eligible
         // encoder's StatsOptions, compute stats in one pass, query each encoder's
-        // expectedRatio(). AlwaysUse short-circuits; Skip excludes; Ratio competes;
-        // null defers to the sample-encoded path below.
+        // expectedRatio(). ALWAYS_USE short-circuits; SKIP excludes; COMPLETE defers
+        // to the sample-encoded path below.
         StatsOptions merged = StatsOptions.NONE;
         for (EncodingEncoder enc : encodings) {
             if (enc.accepts(dtype) && !ctx.excluded().contains(enc.encodingId())) {
@@ -175,9 +175,8 @@ private EncodeResult encodeWithCtx(DType dtype, Object data, EncodeContext ctx)
                                    ? ArrayStats.EMPTY
                                    : ArrayStats.compute(p.ptype(), data, merged);
 
-        // First sweep: stats verdicts. AlwaysUse short-circuits; Skip excludes from
-        // sample-encoded competition below; Ratio acts as a Skip hint (rough estimate,
-        // not directly comparable to cascade-aware sample bytes); null defers.
+        // First sweep: stats verdicts. ALWAYS_USE short-circuits; SKIP excludes from
+        // the sample-encoded competition below; COMPLETE defers to it.
         boolean[] skipMask = new boolean[encodings.size()];
         for (int i = 0; i < encodings.size(); i++) {
             EncodingEncoder enc = encodings.get(i);
@@ -186,10 +185,10 @@ private EncodeResult encodeWithCtx(DType dtype, Object data, EncodeContext ctx)
                 continue;
             }
             Estimate est = enc.expectedRatio(dtype, data, stats);
-            if (est instanceof Estimate.AlwaysUse) {
+            if (est == Estimate.ALWAYS_USE) {
                 return spliceResult(enc, dtype, data, ctx);
             }
-            if (est instanceof Estimate.Skip) {
+            if (est == Estimate.SKIP) {
                 skipMask[i] = true;
             }
         }

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

@@ -33,15 +33,15 @@ public StatsOptions statsOptions() {
     @Override
     public Estimate expectedRatio(DType dtype, Object data, ArrayStats stats) {
         if (stats.valueCount() == 0) {
-            return Estimate.alwaysUse();
+            return Estimate.ALWAYS_USE;
         }
         if (!stats.hasDistinctCount()) {
-            return null;
+            return Estimate.COMPLETE;
         }
         if (stats.distinctCount() == 1) {
-            return Estimate.alwaysUse();
+            return Estimate.ALWAYS_USE;
         }
-        return Estimate.skip();
+        return Estimate.SKIP;
     }
 
     @Override

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

@@ -43,21 +43,21 @@ public StatsOptions statsOptions() {
     public Estimate expectedRatio(DType dtype, Object data, ArrayStats stats) {
         // Stats path only covers Primitive (Utf8 still uses sample-encoded selection).
         if (!(dtype instanceof DType.Primitive) || !stats.hasDistinctCount()) {
-            return null;
+            return Estimate.COMPLETE;
         }
         long n = stats.valueCount();
         long distinct = stats.distinctCount();
         if (n == 0) {
-            return Estimate.skip();
+            return Estimate.SKIP;
         }
         // Rust FloatDictScheme / IntDictScheme skip rule. Skip-only: the raw dict cost
         // ignores cascade bitpacking on the codes child, so a raw ratio over-estimates
         // dict's effectiveness vs encoders like ALP whose sample measure includes cascade.
         // Defer to the sample-encoded path for the actual win.
         if (distinct * 2 > n) {
-            return Estimate.skip();
+            return Estimate.SKIP;
         }
-        return null;
+        return Estimate.COMPLETE;
     }
 
     @Override

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

@@ -53,9 +53,9 @@ default StatsOptions statsOptions() {
     /// @param dtype the logical type of the data
     /// @param data  the input data
     /// @param stats pre-computed stats reflecting the merged [StatsOptions]
-    /// @return [Estimate.Skip] / [Estimate.AlwaysUse], or `null` to defer to the
-    ///         sample-encoded selection path
+    /// @return [Estimate#SKIP] / [Estimate#ALWAYS_USE], or [Estimate#COMPLETE] to
+    ///         defer to the sample-encoded selection path
     default Estimate expectedRatio(DType dtype, Object data, ArrayStats stats) {
-        return null;
+        return Estimate.COMPLETE;
     }
 }

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

@@ -1,34 +1,15 @@
 package io.github.dfa1.vortex.writer.encode;
 
-/// Compression estimate returned by an [EncodingEncoder] given pre-computed [ArrayStats].
-///
-/// Two terminal verdicts:
-/// - [Skip] — encoder is incompatible with this input; do not consider.
-/// - [AlwaysUse] — encoder is provably the best choice; pick immediately.
-///
-/// Encoders that are neither incompatible nor provably-best return `null` so the
-/// [CascadingCompressor] competes them by real sample-encode size rather than an
-/// up-front ratio estimate.
-public sealed interface Estimate {
+/// Fast-path verdict an [EncodingEncoder] returns from pre-computed [ArrayStats],
+/// letting the [CascadingCompressor] skip the expensive sample-encode probe.
+public enum Estimate {
 
-    /// Skip this encoder for this input.
-    record Skip() implements Estimate {
-    }
+    /// Encoder is incompatible with this input; exclude it from the competition.
+    SKIP,
 
-    /// Pick this encoder immediately; short-circuit the cascade.
-    record AlwaysUse() implements Estimate {
-    }
+    /// Encoder is provably the best choice; pick it immediately and short-circuit.
+    ALWAYS_USE,
 
-    Estimate SKIP = new Skip();
-    Estimate ALWAYS_USE = new AlwaysUse();
-
-    /// @return the [Skip] verdict singleton
-    static Estimate skip() {
-        return SKIP;
-    }
-
-    /// @return the [AlwaysUse] verdict singleton
-    static Estimate alwaysUse() {
-        return ALWAYS_USE;
-    }
+    /// No shortcut: run the complete sample-encode evaluation to size this encoder.
+    COMPLETE
 }

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

@@ -37,20 +37,20 @@ public StatsOptions statsOptions() {
     @Override
     public Estimate expectedRatio(DType dtype, Object data, ArrayStats stats) {
         if (!(dtype instanceof DType.Primitive) || !stats.hasDistinctCount()) {
-            return null;
+            return Estimate.COMPLETE;
         }
         long n = stats.valueCount();
         long distinct = stats.distinctCount();
         if (n == 0) {
-            return Estimate.skip();
+            return Estimate.SKIP;
         }
         // Skip rule: if every value is distinct, each row is its own run — pure overhead.
         // Defer to the sample-encoded path otherwise; RunEnd's actual compression depends
         // on run-length distribution which is not summarised by distinct count alone.
         if (distinct >= n) {
-            return Estimate.skip();
+            return Estimate.SKIP;
         }
-        return null;
+        return Estimate.COMPLETE;
     }
 
     @Override

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

@@ -39,16 +39,16 @@ public StatsOptions statsOptions() {
     @Override
     public Estimate expectedRatio(DType dtype, Object data, ArrayStats stats) {
         if (!(dtype instanceof DType.Primitive) || !stats.hasMostFrequent()) {
-            return null;
+            return Estimate.COMPLETE;
         }
         long n = stats.valueCount();
         // Sparse stores fill scalar (hardcoded 0) + n - topFreq patches. Skip unless the
         // dominant value's bit pattern is zero AND it covers more than half the array —
         // otherwise the patch buffer dwarfs raw storage.
         if (n == 0 || stats.mostFrequentBits() != 0L || stats.topFrequency() * 2 < n) {
-            return Estimate.skip();
+            return Estimate.SKIP;
         }
-        return null;
+        return Estimate.COMPLETE;
     }
 
     /// Cascade gate: skip unless analytic sparse size beats raw-bitpacked size.