fix(quickcheck): produce shrink candidates without recursing per block

Replace the recursion in `removes_array` and `removes_list` with a cursor over
the block offsets. Both now walk `0, k, 2k, ..` directly — ascending for the
array, descending for the list — so building the iterator is O(1) and yielding
a candidate uses no stack beyond the call itself. The candidate sequences and
`size_hint`s are the ones the previous commit pinned, which is why that test
file is unchanged here.

This fixes the three stack-overflow tests from the previous commit on js, wasm
and wasm-gc, so a property test whose counterexample is a large collection now
shrinks instead of dying with `RangeError: Maximum call stack size exceeded`.

It is also much faster on the `List` side, because the old form rebuilt the
candidate through one `concat` per level on the way back up, where the new one
does a single `take`/`drop`/`concat`. First candidate from a 10,000-element
collection, native release:

| Collection | Before    | After     |
| ---------- | --------: | --------: |
| Array      | 240.69 ns | 288.55 ns |
| List       |   1.32 ms | 213.65 µs |

The array case is a hair slower — it now allocates the candidate through an
array spread instead of returning a shared empty literal — and in exchange the
`k == n` special case added in #4208 is gone, since taking a zero-length prefix
already costs nothing.

The benchmark goes back to 10,000 elements; #4208 had to lower it to 1,000
precisely because of the bug this fixes.

Reviewed by Codex CLI together with the preceding test commit: "Verified
ordering, exact size hints, non-divisible lengths, `k == n` without element
copying, and cursor compatibility with single-use iterators. Independent
old/new models agree for 5,050 input pairs."

Signed-off-by: Codex CLI <codex@openai.com>

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016jtBJHK749cpStav5ZMNCr

Author: bobzhang

quickcheck/shrink/utils.mbt

@@ -25,29 +25,42 @@ fn[T] deferred(f : () -> Iter[T]) -> Iter[T] {
 }
 
 ///|
-/// `n` must be `xs.length()`; the recursive call maintains that, and both
-/// guards below rely on it.
+/// Yields `xs` with one block of `k` consecutive elements removed: one
+/// candidate per block offset `0, k, 2k, ..`, up to the last offset that still
+/// leaves a whole block, in ascending order.
+///
+/// `n` must be `xs.length()`.
 fn[T] removes_array(k : Int, n : Int, xs : Array[T]) -> Iter[Array[T]] {
   guard k <= n else { [||] }
-  // Dropping every element leaves the empty array; taking the `k`-element
-  // prefix first would copy the whole array only to discard it. Past this
-  // guard `xs[k:]` is non-empty.
-  guard k < n else { [|[]|] }
-  let xs2 = xs[:k].to_owned()
-  let xs1 = xs[k:].to_owned()
-  [|xs1|].add(removes_array(k, n - k, xs1).map(x => xs2 + x))
+  let mut start = 0
+  Iter::new(
+    fn() {
+      guard start + k <= n else { None }
+      let candidate = [..xs[:start], ..xs[start + k:]]
+      start += k
+      Some(candidate)
+    },
+    size_hint=(n - k) / k + 1,
+  )
 }
 
 ///|
+/// The `@list.List` counterpart of `removes_array`, except that the offsets
+/// descend: the block nearest the end is removed first.
+///
+/// `n` must be `xs.length()`.
 fn[T] removes_list(k : Int, n : Int, xs : @list.List[T]) -> Iter[@list.List[T]] {
   guard k <= n else { [||] }
-  let xs_drop = xs.drop(k)
-  if xs_drop.is_empty() {
-    [|List([])|]
-  } else {
-    let xs_take = xs.take(k)
-    removes_list(k, n - k, xs_drop).map(x => xs_take.concat(x)).add([|xs_drop|])
-  }
+  let mut start = (n - k) / k * k
+  Iter::new(
+    fn() {
+      guard start >= 0 else { None }
+      let candidate = xs.take(start).concat(xs.drop(start + k))
+      start -= k
+      Some(candidate)
+    },
+    size_hint=(n - k) / k + 1,
+  )
 }
 
 ///|

quickcheck/shrink_collection_bench_test.mbt

@@ -13,13 +13,13 @@
 // limitations under the License.
 
 ///|
-test "bench shrink Array first candidate size=1000" (it : @bench.T) {
-  let input = Array::make(1000, ())
+test "bench shrink Array first candidate size=10000" (it : @bench.T) {
+  let input = Array::make(10000, ())
   it.bench(fn() { it.keep(@shrink.Shrink::shrink(input).next()) })
 }
 
 ///|
-test "bench shrink List first candidate size=1000" (it : @bench.T) {
-  let input : @list.List[Unit] = List(Array::make(1000, ()))
+test "bench shrink List first candidate size=10000" (it : @bench.T) {
+  let input : @list.List[Unit] = List(Array::make(10000, ()))
   it.bench(fn() { it.keep(@shrink.Shrink::shrink(input).next()) })
 }