perf: Optimize replace() fastpath by avoiding alloc (#20344)

## Which issue does this PR close?

- Closes #20343.

## Rationale for this change

We already have a fastpath for when `from` and `to` are both single
ASCII characters, but this fastpath could be further optimized by
avoiding the `Vec<u8>` allocation.

## What changes are included in this PR?

Implement the described optimization.

## Are these changes tested?

Yes, no new tests or benchmarks warranted. This PR yields a 10-50%
performance improvement for the relevant microbenchmarks.

## Are there any user-facing changes?

No.

Author: neilconway

datafusion/functions/src/string/replace.rs

@@ -228,19 +228,21 @@ fn replace_into_string(buffer: &mut String, string: &str, from: &str, to: &str)
         return;
     }
 
-    // Fast path for replacing a single ASCII character with another single ASCII character
-    // This matches Rust's str::replace() optimization and enables vectorization
+    // Fast path for replacing a single ASCII character with another single ASCII character.
+    // Extends the buffer's underlying Vec<u8> directly, for performance.
     if let ([from_byte], [to_byte]) = (from.as_bytes(), to.as_bytes())
         && from_byte.is_ascii()
         && to_byte.is_ascii()
     {
-        // SAFETY: We're replacing ASCII with ASCII, which preserves UTF-8 validity
-        let replaced: Vec<u8> = string
-            .as_bytes()
-            .iter()
-            .map(|b| if *b == *from_byte { *to_byte } else { *b })
-            .collect();
-        buffer.push_str(unsafe { std::str::from_utf8_unchecked(&replaced) });
+        // SAFETY: Replacing an ASCII byte with another ASCII byte preserves UTF-8 validity.
+        unsafe {
+            buffer.as_mut_vec().extend(
+                string
+                    .as_bytes()
+                    .iter()
+                    .map(|&b| if b == *from_byte { *to_byte } else { b }),
+            );
+        }
         return;
     }