Add append_value_n to GenericByteBuilder (apache#9426)

# Which issue does this PR close?

- Closes apache#9425.

# Rationale for this change

I noticed that this method is available on PrimitiveTypeBuilder, but
missing on the GenericByteBuilder, which make sense since the gain is
less, but after benchmarking, it shows a solid 10%. Mostly because the
more efficient allocation of the null-mask.

```
┌───────────────────┬────────────────┬───────────────────┬─────────┐
│     Benchmark     │ append_value_n │ append_value loop │ Speedup │
├───────────────────┼────────────────┼───────────────────┼─────────┤
│ n=100/len=5       │ 371 ns         │ 408 ns            │ 10%     │
├───────────────────┼────────────────┼───────────────────┼─────────┤
│ n=100/len=30      │ 456 ns         │ 507 ns            │ 10%     │
├───────────────────┼────────────────┼───────────────────┼─────────┤
│ n=100/len=1024    │ 1.81 µs        │ 1.95 µs           │ 8%      │
├───────────────────┼────────────────┼───────────────────┼─────────┤
│ n=1000/len=5      │ 2.39 µs        │ 2.87 µs           │ 17%     │
├───────────────────┼────────────────┼───────────────────┼─────────┤
│ n=1000/len=30     │ 3.41 µs        │ 3.89 µs           │ 12%     │
├───────────────────┼────────────────┼───────────────────┼─────────┤
│ n=1000/len=1024   │ 12.3 µs        │ 14.4 µs           │ 15%     │
├───────────────────┼────────────────┼───────────────────┼─────────┤
│ n=10000/len=5     │ 23.8 µs        │ 29.3 µs           │ 19%     │
├───────────────────┼────────────────┼───────────────────┼─────────┤
│ n=10000/len=30    │ 33.7 µs        │ 39.0 µs           │ 14%     │
├───────────────────┼────────────────┼───────────────────┼─────────┤
│ n=10000/len=1024  │ 115.9 µs       │ 135.0 µs          │ 14%     │
├───────────────────┼────────────────┼───────────────────┼─────────┤
│ n=100000/len=5    │ 227.5 µs       │ 278.6 µs          │ 18%     │
├───────────────────┼────────────────┼───────────────────┼─────────┤
│ n=100000/len=30   │ 328.1 µs       │ 377.9 µs          │ 13%     │
├───────────────────┼────────────────┼───────────────────┼─────────┤
│ n=100000/len=1024 │ 1.16 ms        │ 1.34 ms           │ 14%     │
└───────────────────┴────────────────┴───────────────────┴─────────┘
```

I think this is still worthwhile to be added. Let me know what the
community thinks!

# What changes are included in this PR?

A new public API.

# Are these changes tested?

Yes!

# Are there any user-facing changes?

A new public API.

Author: Fokko

arrow-array/src/builder/generic_bytes_builder.rs

@@ -110,6 +110,21 @@ impl<T: ByteArrayType> GenericByteBuilder<T> {
         self.offsets_builder.push(self.next_offset());
     }
 
+    /// Appends a value of type `T` into the builder `n` times.
+    ///
+    /// See [`Self::append_value`] for more panic information.
+    #[inline]
+    pub fn append_value_n(&mut self, value: impl AsRef<T::Native>, n: usize) {
+        let bytes: &[u8] = value.as_ref().as_ref();
+        self.value_builder.reserve(bytes.len() * n);
+        self.offsets_builder.reserve(n);
+        for _ in 0..n {
+            self.value_builder.extend_from_slice(bytes);
+            self.offsets_builder.push(self.next_offset());
+        }
+        self.null_buffer_builder.append_n_non_nulls(n);
+    }
+
     /// Append an `Option` value into the builder.
     ///
     /// - A `None` value will append a null value.
@@ -939,4 +954,21 @@ mod tests {
 
         assert!(matches!(result, Err(ArrowError::OffsetOverflowError(_))));
     }
+
+    #[test]
+    fn test_append_value_n() {
+        let mut builder = GenericStringBuilder::<i32>::new();
+        builder.append_value("hello");
+        builder.append_value_n("world", 3);
+        builder.append_null();
+        let array = builder.finish();
+
+        assert_eq!(5, array.len());
+        assert_eq!(1, array.null_count());
+        assert_eq!("hello", array.value(0));
+        assert_eq!("world", array.value(1));
+        assert_eq!("world", array.value(2));
+        assert_eq!("world", array.value(3));
+        assert!(array.is_null(4));
+    }
 }