perf(parquet): vectorise dict-index bounds check in RleDecoder::get_batch_with_dict

Replace `idx_chunk.iter().all(|&i| (i as usize) < dict_len)` with a
u32 max-reduction (`fold(0u32, |acc, &i| acc.max(i as u32))`). `.all`
short-circuits and so blocks autovectorisation; on aarch64 the old
form compiled to eight serialised `ldrsw` + `cmp` + `b.ls` pairs per
8-index chunk, followed by eight separate scalar gather loads.

The max-reduction has no early exit, so LLVM now lowers the check to
a single `ldp q1, q0` + `umax.4s` + `umaxv.4s` + one `cmp` + `b.ls`,
then reuses the loaded NEON registers for the gather that follows.
Negative `i32` values cast to `u32` become large, so the bounds
check still rejects them.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Dandandan

parquet/src/encodings/rle.rs

@@ -520,8 +520,15 @@ impl RleDecoder {
                         let idx_chunks = idx.chunks_exact(8);
                         for (out_chunk, idx_chunk) in out_chunks.by_ref().zip(idx_chunks) {
                             let dict_len = dict.len();
+                            // u32 max-reduction instead of `.all(|&i| ..)`: `.all`
+                            // short-circuits and blocks autovectorisation. Negative
+                            // i32 cast to u32 becomes a large value so the bounds
+                            // check still rejects it.
+                            let max_idx = idx_chunk
+                                .iter()
+                                .fold(0u32, |acc, &i| acc.max(i as u32));
                             assert!(
-                                idx_chunk.iter().all(|&i| (i as usize) < dict_len),
+                                (max_idx as usize) < dict_len,
                                 "dictionary index out of bounds"
                             );
                             for (b, i) in out_chunk.iter_mut().zip(idx_chunk.iter()) {