feat: add apply_unary_op and apply_binary_op bitwise operations (#8619)

# Which issue does this PR close?

- Closes #8618.

# Rationale for this change

Implement efficient boolean by applying them a (u64) at a time

# What changes are included in this PR?


## Implementation notes

# Are these changes tested?

Yes, although I did not run them on big endian machine

# Are there any user-facing changes?

Yes, new functions which are documented


----------------

Notes: I will later change `BooleanBufferBuilder#append_packed_range`
function to use `mutable_bitwise_bin_op_helper` as I saw that running
the `boolean_append_packed` benchmark improved by more than 2 times
```
boolean_append_packed   time:   [2.0079 µs 2.0139 µs 2.0202 µs]
                        change: [−57.808% −57.653% −57.494%] (p = 0.00 < 0.05)
                        Performance has improved.
``` 

See benchmarks on 
- #8744

---------

Co-authored-by: Andrew Lamb <[email protected]>

Author: rluvaton

arrow-buffer/src/buffer/immutable.rs

@@ -524,6 +524,12 @@ impl std::ops::Deref for Buffer {
     }
 }
 
+impl AsRef<[u8]> for &Buffer {
+    fn as_ref(&self) -> &[u8] {
+        self.as_slice()
+    }
+}
+
 impl From<MutableBuffer> for Buffer {
     #[inline]
     fn from(buffer: MutableBuffer) -> Self {

arrow-buffer/src/buffer/mutable.rs

@@ -35,15 +35,18 @@ use super::Buffer;
 
 /// A [`MutableBuffer`] is Arrow's interface to build a [`Buffer`] out of items or slices of items.
 ///
-/// [`Buffer`]s created from [`MutableBuffer`] (via `into`) are guaranteed to have its pointer aligned
+/// [`Buffer`]s created from [`MutableBuffer`] (via `into`) are guaranteed to be aligned
 /// along cache lines and in multiple of 64 bytes.
 ///
 /// Use [MutableBuffer::push] to insert an item, [MutableBuffer::extend_from_slice]
 /// to insert many items, and `into` to convert it to [`Buffer`].
 ///
-/// For a safe, strongly typed API consider using [`Vec`] and [`ScalarBuffer`](crate::ScalarBuffer)
+/// # See Also
+/// * For a safe, strongly typed API consider using [`Vec`] and [`ScalarBuffer`](crate::ScalarBuffer)
+/// * To apply bitwise operations, see [`apply_bitwise_binary_op`] and [`apply_bitwise_unary_op`]
 ///
-/// Note: this may be deprecated in a future release ([#1176](https://github.com/apache/arrow-rs/issues/1176))
+/// [`apply_bitwise_binary_op`]: crate::bit_util::apply_bitwise_binary_op
+/// [`apply_bitwise_unary_op`]: crate::bit_util::apply_bitwise_unary_op
 ///
 /// # Example
 ///
@@ -812,6 +815,12 @@ impl std::ops::DerefMut for MutableBuffer {
     }
 }
 
+impl AsRef<[u8]> for &MutableBuffer {
+    fn as_ref(&self) -> &[u8] {
+        self.as_slice()
+    }
+}
+
 impl Drop for MutableBuffer {
     fn drop(&mut self) {
         if self.layout.size() != 0 {