perf(parquet): force-inline ByteBudgetChunker hot path, split cold path out

The previous `#[inline]` hint was no longer enough once
`pick_sub_batch_size` grew the `ValueCountStrategy` match — LLVM
silently stopped inlining and the most recent GKE bench bounced
`string_dictionary/*` back to +46–81% (`default` +81%, `parquet_2`
+86%, `bloom_filter` +46%).

Fix:

1. Mark `pick_sub_batch_size` `#[inline(always)]`. The hot path is
   just `if static_always_fits || has_dictionary || chunk_size == 0 {
   return chunk_size; }` — one struct-field load + one virtual call —
   so unconditional inlining is the right call, not a heuristic
   suggestion.

2. Pull the byte-budget computation out into a separate
   `byte_budget_sub_batch_size` method marked `#[inline(never)]`. This
   keeps the inlined fast path small even as the slow path grows; the
   slow path is paid for explicitly when bypasses don't fire, not
   smuggled into every chunk's inline body.

Same behavior, just compiler-friendlier code layout.

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

Author: adriangb

parquet/src/column/writer/byte_budget_chunker.rs

@@ -134,12 +134,14 @@ impl ByteBudgetChunker {
     ///   dictionary fallback bound dict-encoded pages independently.
     /// - When `chunk_size == 0`, there's nothing to size.
     ///
-    /// Inlined because the hot path through the bypass conditions reduces
-    /// to one struct-field load + one virtual call into the encoder and
-    /// keeping it across the module boundary stops the compiler from
-    /// folding it into the per-chunk loop's register schedule.
+    /// Hot path: when one of the bypass conditions fires this returns
+    /// `chunk_size` with one struct-field load and one virtual call into
+    /// the encoder. Marked `#[inline(always)]` because LLVM's heuristic
+    /// would otherwise refuse to inline now that the slow path lives
+    /// nearby — the GKE bench showed a +80% regression on
+    /// `string_dictionary/*` when the hint was just `#[inline]`.
     #[allow(clippy::too_many_arguments)]
-    #[inline]
+    #[inline(always)]
     pub(crate) fn pick_sub_batch_size<E: ColumnValueEncoder>(
         &self,
         encoder: &E,
@@ -154,6 +156,33 @@ impl ByteBudgetChunker {
         if self.static_always_fits || encoder.has_dictionary() || chunk_size == 0 {
             return chunk_size;
         }
+        self.byte_budget_sub_batch_size::<E>(
+            values,
+            value_indices,
+            chunk_def,
+            strategy,
+            values_offset,
+            chunk_size,
+            end_offset,
+        )
+    }
+
+    /// Cold path: the encoder is plain-encoding and the bypass conditions
+    /// didn't fire, so we have to look at value sizes to decide whether
+    /// the chunk fits. Pulled out of `pick_sub_batch_size` and marked
+    /// `#[inline(never)]` so the inlined fast path stays small.
+    #[allow(clippy::too_many_arguments)]
+    #[inline(never)]
+    fn byte_budget_sub_batch_size<E: ColumnValueEncoder>(
+        &self,
+        values: &E::Values,
+        value_indices: Option<&[usize]>,
+        chunk_def: LevelDataRef<'_>,
+        strategy: ValueCountStrategy<'_>,
+        values_offset: usize,
+        chunk_size: usize,
+        end_offset: usize,
+    ) -> usize {
         // Count how many values fall in this chunk's level range. The
         // strategy was picked once per `write_batch_internal` call so
         // the common all-non-null case (every level has a value) skips