BytesIter to read by index instead of re-slicing per byte (the VecTryIter approach) (#1935)

### What

Changed the implementation of `BytesIter` to match the more efficient
implementation of `VecTryIter`.

### Why

This reduces the need to allocate memory and increases performance. This
is benchmarked on [dkcumming/rs-soroban-sdk branch
dc/bytes-from-zc-bench](main...dkcumming:rs-soroban-sdk:dc/bytes-iter-bench).
For completeness the key end-to-end results are communicated in this
table:

| Bench | Before CPU | After CPU | Δ % | Before Mem | After Mem | Δ % |

|-------------------|-----------:|----------:|-------:|-----------:|----------:|------:|
| `baseline_*` | 245,345 | 232,140 | -5.4% | 1,146,818 | 1,144,946 |
-0.2% |
| `iter_32` | 386,297 | 258,596 | -33.1% | 1,151,154 | 1,144,946 | -0.5%
|
| `iter_rev_32` | 364,213 | 259,068 | -28.9% | 1,151,154 | 1,144,946 |
-0.5% |
| `iter_48` | 456,057 | 271,268 | -40.5% | 1,153,706 | 1,144,946 | -0.8%
|
| `iter_rev_48` | 422,837 | 271,740 | -35.7% | 1,153,706 | 1,144,946 |
-0.8% |
| `iter_96` | 665,721 | 309,284 | -53.5% | 1,162,898 | 1,144,946 | -1.5%
|
| `iter_rev_96` | 599,093 | 309,756 | -48.3% | 1,162,898 | 1,144,946 |
-1.5% |
| `iter_192` | 1,086,777 | 385,316 | -64.5% | 1,188,194 | 1,144,946 |
-3.6% |
| `iter_rev_192` | 953,333 | 385,788 | -59.5% | 1,188,194 | 1,144,946 |
-3.6% |

The tests to run these benchmarks were:

<details>

The contract:

```rust
#![no_std]
use soroban_sdk::{contract, contractimpl, Bytes, Env};

#[contract]
pub struct Contract;

// Each function derives its result from every byte so the iteration cannot be
// optimized out of the guest Wasm.
//
// `baseline` has the same signature as the iterating functions, so subtracting
// it isolates the iteration cost from dispatch and operand-passing overhead.

#[contractimpl]
impl Contract {
    pub fn baseline(_env: Env, _b: Bytes) -> u32 {
        0
    }

    pub fn sum_iter(_env: Env, b: Bytes) -> u32 {
        let mut acc: u32 = 0;
        for x in b.iter() {
            acc = acc.wrapping_add(x as u32);
        }
        acc
    }

    pub fn sum_iter_rev(_env: Env, b: Bytes) -> u32 {
        let mut acc: u32 = 0;
        for x in b.iter().rev() {
            acc = acc.wrapping_add(x as u32);
        }
        acc
    }
}
```

The benchmark harnesses:

```rust
//! Compute-budget microbenches for iterating a `Bytes` (host-function metering
//! only).
//!
//! These benches are disabled by default (`#[ignore]`) because:
//! 1. they should be run under `--release` rather than the default test profile.
//! 2. their output is only meaningful with `--nocapture`.
//!
//! Run with the following command:
//! cargo test --release --package soroban-sdk --lib --features testutils \
//!   -- tests::bytes_iter_bench --ignored --nocapture
use crate::{Bytes, Env};

fn report(label: &str, env: &Env) {
    let cpu = env.cost_estimate().budget().cpu_instruction_cost();
    let mem = env.cost_estimate().budget().memory_bytes_cost();
    println!("BENCH {label} cpu={cpu} mem={mem}");
}

macro_rules! bench_iter {
    ($fwd:ident, $rev:ident, $n:literal) => {
        #[test]
        #[ignore]
        fn $fwd() {
            let env = Env::default();
            let b = Bytes::from_slice(&env, &[7u8; $n]);
            env.cost_estimate().budget().reset_unlimited();
            let mut acc: u32 = 0;
            for x in b.iter() {
                acc = acc.wrapping_add(x as u32);
            }
            core::hint::black_box(acc);
            report(stringify!($fwd), &env);
        }

        #[test]
        #[ignore]
        fn $rev() {
            let env = Env::default();
            let b = Bytes::from_slice(&env, &[7u8; $n]);
            env.cost_estimate().budget().reset_unlimited();
            let mut acc: u32 = 0;
            for x in b.iter().rev() {
                acc = acc.wrapping_add(x as u32);
            }
            core::hint::black_box(acc);
            report(stringify!($rev), &env);
        }
    };
}

bench_iter!(bench_iter_32, bench_iter_rev_32, 32);
bench_iter!(bench_iter_48, bench_iter_rev_48, 48);
bench_iter!(bench_iter_96, bench_iter_rev_96, 96);
bench_iter!(bench_iter_192, bench_iter_rev_192, 192);
```

</details>

### Known limitations

No known limitations with this approach. This was a targeted
investigation and is not comprehensive in scope, there may be other
places where similar improvements can be made.

Co-authored-by: Leigh <351529+leighmcculloch@users.noreply.github.com>

Author: dkcumming

soroban-sdk/src/bytes.rs

@@ -839,57 +839,53 @@ impl IntoIterator for Bytes {
     type IntoIter = BytesIter;
 
     fn into_iter(self) -> Self::IntoIter {
-        BytesIter(self)
+        BytesIter::new(self)
     }
 }
 
 #[derive(Clone)]
-pub struct BytesIter(Bytes);
+pub struct BytesIter {
+    bin: Bytes,
+    start: u32, // inclusive
+    end: u32,   // exclusive
+}
 
 impl BytesIter {
-    fn into_bin(self) -> Bytes {
-        self.0
+    fn new(bin: Bytes) -> Self {
+        Self {
+            start: 0,
+            end: bin.len(),
+            bin,
+        }
     }
 }
 
 impl Iterator for BytesIter {
     type Item = u8;
 
     fn next(&mut self) -> Option<Self::Item> {
-        if self.0.is_empty() {
-            None
+        if self.start < self.end {
+            let val = self.bin.get_unchecked(self.start);
+            self.start += 1;
+            Some(val)
         } else {
-            let val: u32 = self
-                .0
-                .env()
-                .bytes_front(self.0.obj)
-                .unwrap_infallible()
-                .into();
-            self.0 = self.0.slice(1..);
-            Some(val as u8)
+            None
         }
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
-        let len = self.0.len() as usize;
+        let len = (self.end - self.start) as usize;
         (len, Some(len))
     }
 }
 
 impl DoubleEndedIterator for BytesIter {
     fn next_back(&mut self) -> Option<Self::Item> {
-        let len = self.0.len();
-        if len == 0 {
-            None
+        if self.start < self.end {
+            self.end -= 1;
+            Some(self.bin.get_unchecked(self.end))
         } else {
-            let val: u32 = self
-                .0
-                .env()
-                .bytes_back(self.0.obj)
-                .unwrap_infallible()
-                .into();
-            self.0 = self.0.slice(..len - 1);
-            Some(val as u8)
+            None
         }
     }
 }
@@ -898,7 +894,7 @@ impl FusedIterator for BytesIter {}
 
 impl ExactSizeIterator for BytesIter {
     fn len(&self) -> usize {
-        self.0.len() as usize
+        (self.end - self.start) as usize
     }
 }
 
@@ -1304,7 +1300,7 @@ impl<const N: usize> IntoIterator for BytesN<N> {
     type IntoIter = BytesIter;
 
     fn into_iter(self) -> Self::IntoIter {
-        BytesIter(self.0)
+        BytesIter::new(self.0)
     }
 }
 
@@ -1532,6 +1528,80 @@ mod test {
         assert_eq!(iter.next_back(), None);
     }
 
+    #[test]
+    fn test_bin_iter_large() {
+        let env = Env::default();
+        const N: usize = 100;
+        let mut data = [0u8; N];
+        for i in 0..N {
+            data[i] = i as u8;
+        }
+        let bin = Bytes::from_slice(&env, &data);
+
+        // Forward yields every byte in order, exactly N of them.
+        let mut count = 0usize;
+        for (i, b) in bin.iter().enumerate() {
+            assert_eq!(b, data[i]);
+            count += 1;
+        }
+        assert_eq!(count, N);
+
+        // Reverse yields every byte in reverse order.
+        let mut expect = N;
+        for b in bin.iter().rev() {
+            expect -= 1;
+            assert_eq!(b, data[expect]);
+        }
+        assert_eq!(expect, 0);
+
+        // ExactSizeIterator length tracks remaining across a bulk chunk read.
+        let mut it = bin.iter();
+        assert_eq!(it.len(), N);
+        assert_eq!(it.size_hint(), (N, Some(N)));
+        it.next();
+        assert_eq!(it.len(), N - 1);
+
+        // Interleaved double-ended iteration: the front and back cursors must
+        // meet correctly in the middle.
+        let mut it = bin.iter();
+        let mut lo = 0usize;
+        let mut hi = N;
+        let mut front = true;
+        while lo < hi {
+            if front {
+                assert_eq!(it.next(), Some(data[lo]));
+                lo += 1;
+            } else {
+                assert_eq!(it.next_back(), Some(data[hi - 1]));
+                hi -= 1;
+            }
+            front = !front;
+        }
+        assert_eq!(it.next(), None);
+        assert_eq!(it.next_back(), None);
+        assert_eq!(it.len(), 0);
+
+        for len in [32usize, 33] {
+            let mut d = [0u8; 33];
+            for i in 0..len {
+                d[i] = (200 - i) as u8;
+            }
+            let b = Bytes::from_slice(&env, &d[..len]);
+            let mut i = 0;
+            for x in b.iter() {
+                assert_eq!(x, d[i]);
+                i += 1;
+            }
+            assert_eq!(i, len);
+            let mut j = len;
+            for x in b.iter().rev() {
+                j -= 1;
+                assert_eq!(x, d[j]);
+            }
+            assert_eq!(j, 0);
+        }
+    }
+
     #[test]
     fn test_array_binary_borrow() {
         fn get_len(b: impl Borrow<Bytes>) -> u32 {