fix(parse): use as_chunks for a constant chunk size

Unrelated to this PR's bug fix, and included only because it blocks CI for
everything.

`chunks_exact_to_as_chunks` is a clippy lint added in Rust 1.98. CI runs a
toolchain new enough to have it; the line it flags predates this branch and is
untouched by it, so `main` is red for the same reason and every open PR against
this repo is blocked identically.

`as_chunks::<2>()` returns fixed-size arrays, so the two destructurings need no
bounds check and the pair can be bound directly in the pattern.

Verified on both sides of the lint's introduction: clean under nightly 1.99
(which reproduces CI's failure exactly) and still building under 1.96.1, so this
does not require the newer toolchain to compile.

Kept as its own commit so it can be dropped or cherry-picked independently of the
UTF-8 fix.

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

Author: CodeGhost21

src/harness/tool_calling/parse.rs

@@ -224,9 +224,13 @@ fn normalize_garbled_tool_call_tags(s: &str) -> Cow<'_, str> {
     }
     let mut out = String::with_capacity(s.len());
     let mut cursor = 0usize;
-    for pair in tags.chunks_exact(2) {
-        let (open_start, open_end) = pair[0];
-        let (close_start, close_end) = pair[1];
+    // `as_chunks::<2>()` rather than `chunks_exact(2)`: the chunk size is a
+    // constant, so this hands back fixed-size arrays and the two destructurings
+    // below need no bounds check. `chunks_exact_to_as_chunks` (clippy, Rust
+    // 1.98) flags the older form.
+    for &[open, close] in tags.as_chunks::<2>().0 {
+        let (open_start, open_end) = open;
+        let (close_start, close_end) = close;
         out.push_str(&s[cursor..open_start]); // text before the open tag, verbatim
         out.push_str("<tool_call>");
         // Strip the `call:` prefix, then try to recover a Kimi-family