feat: add wrap_around() for indefinite iteration on sequential and write iterators

- Add wrap_around() method to SequentialIter for cycling through IDs
- Add wrap_around() method to WriteIter for claiming IDs indefinitely
- WriteIter wrap_around clears bitmap each cycle to re-claim IDs
- SequentialIter wrap_around restarts from id_min when reaching end
- Add multi-threaded tests for both wrap_around modes
- Update README.md with wrap_around examples and comparison table
- Update INTEGRATION_GUIDE.md with wrap_around documentation and API reference

Iterator behavior summary:
- sequential().wrap_around(): cycles through matching IDs indefinitely
- write().wrap_around(): clears bitmap and restarts when exhausted
- random(): already cycles via sampling (no wrap needed)

Author: zvi-code

INTEGRATION_GUIDE.md

@@ -226,7 +226,38 @@ Statistical distributions for realistic workload simulation:
 | **Sequential** | `.sequential()` | Yes (partitioned) | Cache warming, full scan |
 | **Random** | `.random()` | Yes (partitioned) | Random access patterns |
 | **Overlapping** | `.overlapping().random()` | Yes | Contention testing |
-| **Claim** | `.claim()` | Yes (atomic) | Exactly-once processing |
+| **Claim** | `.write()` / `.continue_write()` | Yes (atomic) | Exactly-once processing |
+
+### Wrap-Around for Indefinite Iteration
+
+By default, iterators stop when the keyspace is exhausted. For benchmarks requiring
+indefinite iteration, use `.wrap_around()`:
+
+| Iterator | Default | With `.wrap_around()` |
+|----------|---------|----------------------|
+| `sequential()` | Stops at end | Cycles back to start |
+| `write()` | Stops when full | Clears bitmap, restarts |
+| `random()` | Samples with replacement | Already cycles (no wrap needed) |
+
+```rust
+// Sequential read - cycles through existing keys forever
+let mut iter = tracker.iter().set_only().sequential().wrap_around();
+
+// Write with wrap - clears and restarts when full
+let mut iter = tracker.iter().write().wrap_around();
+
+// Multi-threaded write with wrap-around
+tracker.reset_write_cursor();
+let handles: Vec<_> = (0..num_workers).map(|_| {
+    let t = tracker.clone();
+    thread::spawn(move || {
+        let mut iter = t.iter().continue_write().wrap_around();
+        for _ in 0..requests_per_worker {
+            iter.next().unwrap(); // Never returns None
+        }
+    })
+}).collect();
+```
 
 ### Partitioning Strategies
 
@@ -786,6 +817,20 @@ impl<'a> TrackerIterBuilder<'a> {
     /// Use when multiple workers share cursor state.
     pub fn continue_write(self) -> WriteIter<'a>;
 }
+
+/// SequentialIter methods
+impl SequentialIter<'a> {
+    /// Enable wrap-around: when iteration reaches end, restart from beginning.
+    /// Useful for benchmarks that read existing keys indefinitely.
+    pub fn wrap_around(self) -> Self;
+}
+
+/// WriteIter methods
+impl WriteIter<'a> {
+    /// Enable wrap-around: when keyspace exhausted, reset cursor and clear
+    /// bitmap to allow re-claiming IDs indefinitely.
+    pub fn wrap_around(self) -> Self;
+}
 ```
 
 ### BitmapSnapshot

README.md

@@ -189,6 +189,12 @@ for (id, _) in tracker.iter()
 {
     // ...
 }
+
+// Wrap-around for indefinite iteration
+let mut iter = tracker.iter().set_only().sequential().wrap_around();
+for _ in 0..1_000_000 {
+    let (id, _) = iter.next().unwrap(); // Cycles through set IDs forever
+}
 ```
 
 ### Random Iterator
@@ -333,6 +339,43 @@ let all_claimed: Vec<u64> = handles.into_iter()
 | `write()` | Resets cursor to 0 | Single iterator, fresh start |
 | `continue_write()` | Keeps current position | Multiple workers sharing cursor |
 
+#### Wrap-Around Mode
+
+By default, iterators return `None` when the keyspace is exhausted. For benchmarks
+that need indefinite iteration, enable wrap-around on any iterator type:
+
+```rust
+// Sequential wrap-around (read existing keys indefinitely)
+let mut iter = tracker.iter().set_only().sequential().wrap_around();
+for _ in 0..1_000_000 {
+    let (id, _) = iter.next().unwrap(); // Cycles through set IDs
+}
+
+// Write wrap-around (claim IDs indefinitely, clears bitmap each cycle)
+let mut iter = tracker.iter().write().wrap_around();
+for _ in 0..1_000_000 {
+    let (id, _) = iter.next().unwrap(); // Cycles through 0..max_id
+}
+
+// Multi-threaded wrap-around
+tracker.reset_write_cursor();
+let handles: Vec<_> = (0..8).map(|_| {
+    let t = tracker.clone();
+    thread::spawn(move || {
+        let mut iter = t.iter().continue_write().wrap_around();
+        for _ in 0..10_000 {
+            iter.next().unwrap();
+        }
+    })
+}).collect();
+```
+
+| Iterator | `wrap_around()` Behavior |
+|----------|-------------------------|
+| `sequential()` | Restarts from `id_min` when reaching end |
+| `write()` | Resets cursor, clears bitmap, restarts claiming |
+| `random()` | Already cycles via sampling (no wrap needed) |
+
 ### Delete Iterator
 
 Exclusive iterator that clears IDs: