feat(array): builders skip child canonicalization and append nested values in bulk [builders-child-stack] (#9064)

Collapses the first four PRs of the builders-child-stack into one
(#8964, #8966, and #9131 were closed and folded in here):

With this change all builders lose set_validity method as it's no longer
used in the codebase and there are always better ways of expressing the
desired operation

- **Append repeated and viewed lists in bulk, not a value at a time** —
bulk-append paths for repeated and viewed lists, and sparse array
canonicalisation no longer goes through scalars.
- **Builders no longer canonicalize their children** (#8964).
- **Accumulate nested builder validity without a null buffer** (#8966).
- **Append constant runs and sparse patches without slicing or
canonicalizing** (#9131) — constant structs, extensions, and fixed-size
lists append directly; sparse patches and fills append without slicing
the patch array; the fixed-size-list fill tile is built once, not once
per gap.

---------

Signed-off-by: Robert Kruszewski <github@robertk.io>
Signed-off-by: Robert Kruszewski <robert@spiraldb.com>
Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: robert3005

encodings/sparse/src/canonical.rs

@@ -338,6 +338,7 @@ mod tests {
 
     use crate::ArrayRef;
     use crate::IntoArray;
+    use crate::RecursiveCanonical;
     use crate::VortexSessionExecute;
     use crate::aggregate_fn::Accumulator;
     use crate::aggregate_fn::AggregateFnVTable;
@@ -376,15 +377,26 @@ mod tests {
     use crate::scalar::ScalarValue;
     use crate::validity::Validity;
 
+    /// The size the array occupies once rebuilt through the canonical builders, which is the
+    /// layout [`UncompressedSizeInBytes`] is defined against: the builders normalize physical
+    /// widths that the input array is free to choose differently, picking the smallest decimal
+    /// value type for a precision and `u64` list-view offsets and sizes.
+    ///
+    /// Builders no longer canonicalize their children, so the finished array is only canonical at
+    /// the top level - recursively canonicalize it before measuring.
     fn materialized_uncompressed_size_in_bytes(array: &ArrayRef) -> u64 {
+        let mut ctx = array_session().create_execution_ctx();
         let mut builder = builder_with_capacity(array.dtype(), array.len());
         array
-            .append_to_builder(
-                builder.as_mut(),
-                &mut array_session().create_execution_ctx(),
-            )
+            .append_to_builder(builder.as_mut(), &mut ctx)
             .vortex_expect("appended");
-        builder.finish().nbytes()
+        builder
+            .finish()
+            .execute::<RecursiveCanonical>(&mut ctx)
+            .vortex_expect("recursively canonicalized")
+            .0
+            .into_array()
+            .nbytes()
     }
 
     fn aggregate(array: &ArrayRef) -> VortexResult<u64> {