Introduce `ValidityKind`/`resolve_validity`: resolve a column's validity once,
materializing the per-row mask only when the column may actually contain nulls.
The size pass for varbinview and the bool and primitive encoders now branch once
on validity, so the all-valid path drops the per-row `mask.value(i)` check (and
mask allocation) entirely.

Signed-off-by: Joe Isaacs <joe.isaacs@live.co.uk>

Every byte of the output range is written by some encoder: fixed-width null rows
write sentinel + explicit zero-fill, varlen encoders zero-pad their final partial
block, and struct/FSL null parent bodies are overwritten with the canonical null
encoding. The pre-zero-init memset is therefore redundant, so replace it with
`set_len`, saving a `total_len`-byte memset per call.

Signed-off-by: Joe Isaacs <joe.isaacs@live.co.uk>

Materialize the listview offsets buffer with `set_len` + a slice write instead of
per-row `push`. For the pure-fixed path, `iter_mut().enumerate()` lets LLVM
auto-vectorize `offsets[i] = i * fixed_per_row` (no per-element bounds or capacity
checks). `nrows` is validated to fit u32 at function entry, so the cast is exact.

Signed-off-by: Joe Isaacs <joe.isaacs@live.co.uk>

Write the mixed (fixed + varlen) offsets through `iter_mut().zip` with wrapping
arithmetic, mirroring the pure-fixed path: this elides per-element bounds checks so
the `i * fixed_per_row` multiply auto-vectorizes while the varlen prefix sum stays a
cheap sequential accumulator. The total is validated to fit u32 upstream, so the
wrapping operations never actually wrap.

Signed-off-by: Joe Isaacs <joe.isaacs@live.co.uk>

…ping

The varlen body writer was a per-byte XOR loop. Split it into an ascending fast
path (`copy_nonoverlapping` of each 32-byte block plus a single stamped continuation
byte, then a partial final block) and a descending path that XORs a u64 at a time via
`xor_copy_block` for a vectorizable inner loop. The emitted bytes are identical to the
previous implementation for every length and direction (full-block counts and final
length byte match exactly); only the write strategy changes.

Signed-off-by: Joe Isaacs <joe.isaacs@live.co.uk>

Replace the `with_iterator` traversal in `encode_varbinview` with a direct walk over
the view array: cache the data-buffer slices once, then for each row read the bytes
straight from the inlined view slot or the referenced buffer at `offset..offset+len`.
This drops the iterator's per-row option/bounds machinery. Validity is resolved once
via `resolve_validity`, keeping the no-nulls path branch-free on validity.

Signed-off-by: Joe Isaacs <joe.isaacs@live.co.uk>

The auto-vectorized offset loops and the varlen block writer used raw `as` casts
that trip this crate's `cast_possible_truncation` lint. Iterate a `u32` counter
instead of casting `usize` per element, and use `u8`/`u32` `try_from` for the
varlen final-block length byte and total byte count. No behavior change.

Signed-off-by: Joe Isaacs <joe.isaacs@live.co.uk>

Classify each column in the size pass (`ColKind` + `first_varlen_idx`): a fixed-width
column with no varlen column before it has a constant within-row offset, so its write
position is pure arithmetic (`i * fixed_per_row + prefix + var_prefix[i]`) with no
per-row cursor. Route those columns through `field_encode_fixed_arithmetic`; the cursor
path is seeded to start at the first varlen column. Primitive columns in the pure-fixed
case use a `chunks_exact_mut` hot loop (matching arrow-row's not-null path); all other
fixed types reuse the cursor encoder at the computed offsets, so output is byte-identical.

Signed-off-by: Joe Isaacs <joe.isaacs@live.co.uk>

FSST is not order-preserving, so row keys must be the decompressed bytes; the only
strategy today is decompress to a canonical VarBinView then row-encode it. This bench
measures that path and its two phases (decompress-only, and row-encode of an
already-decompressed column) on compressible multi-block strings, to quantify the
opportunity for a future fused FSST row-encode kernel: the phases are additive
(decompress ~46%, row-encode ~54%), and the row-encode phase re-reads/re-writes the
decompressed bytes a fused kernel could emit once.

Signed-off-by: Joe Isaacs <joe.isaacs@live.co.uk>

Apply nightly rustfmt formatting to the FSST benchmark added in the previous commit.

Signed-off-by: Joe Isaacs <joe.isaacs@live.co.uk>

Adds `fsst_fast_fused`: bulk-decompresses the FSST code heap straight into a
contiguous buffer (no intermediate VarBinViewArray) and block-encodes rows directly
into the row-key ListView using the stored uncompressed_lengths (free size pass), with
the same no-zero-init / no-extra-copy techniques as the row encoder. Lets us compare
the fused path head-to-head against decode-then-convert.

Signed-off-by: Joe Isaacs <joe.isaacs@live.co.uk>