mruby-regexp: stop a repetition on its empty iteration - #7071

A repetition whose body can match empty runs one final iteration that
consumes nothing. That iteration is the one that ends the loop, and the group
inside it keeps what it captured there: the empty string at the position the
loop stopped at. `pike_vm()` stops one iteration earlier, so the group still
holds the text of the last iteration that consumed something, or nothing at
all when there was none. A body that prefers its empty branch does not end
the loop either, which moves the whole match.

```ruby
/(a?)*/.match("a")[1]        # CRuby: "",  mruby: "a"
/(a?)*/.match("a").begin(1)  # CRuby: 1,   mruby: 0
/(a*)*b/.match("aab")[1]     # CRuby: "",  mruby: "aa"
/(a?)+/.match("a")[1]        # CRuby: "",  mruby: "a"
/(a?)*/.match("b")[1]        # CRuby: "",  mruby: nil
/(a*)*b/.match("b")[1]       # CRuby: "",  mruby: nil
/(|a)*/.match("a")[0]        # CRuby: "",  mruby: "a"
```

The capture reaches results the caller sees:

```ruby
"ab".split(/(a?)*/, -1)  # CRuby: ["", "", "b", "", ""],  mruby: ["", "a", "b", ""]
"ab".scan(/(a?)*/)       # CRuby: [[""], [""], [""]],     mruby: [["a"], [nil], [nil]]
```

`e*` compiles to a `RE_SPLIT` head, the body, and a backward `RE_JMP` to that
head; `e+` closes with a backward fork instead. `add_thread()` walks each `pc`
once per step, marking `visited[pc]` and returning on a revisit, which is what
makes an epsilon loop terminate. The empty iteration is walked and writes its
`RE_SAVE`s into a capture slot, then reaches a `pc` the same walk already
marked, so that slot dies. The thread that leaves the loop was queued by the
head before the body ran, and carries the slot from before the iteration.

Give the backward edge the rule Onigmo applies. Reaching it with the loop head
already marked at this position means the body just ran empty, so leave the
loop from there, carrying that iteration's captures. The head explores the
body before the exit, so this path claims the exit `pc` first and outranks the
stale exit the head queued.

That alone still loses the empty iteration when the closure resumed inside the
body: the character the previous iteration consumed enqueued the thread
mid-body, and that iteration's tail is already marked. So a walk that crosses
a backward edge whose head is unmarked continues in a fresh pass. `visited[pc]`
holds a key per pass, and a later pass may re-walk what an earlier one marked.
The pass count is bounded by how deeply the empty-capable repetitions nest,
which `mark_empty_loops()` computes once at compile time, and by
`RE_MAX_PASS`, so an epsilon loop still terminates and one `pc` still enqueues
a bounded number of threads. `RE_LIST_CAPA()` sizes the thread lists from that
same bound and is now shared with the cache the compiler preallocates for the
VM, so the two cannot drift.

`mark_empty_loops()` also flags each backward edge whose body can run empty,
and only a flagged edge takes any of this. A repetition that always consumes
keeps its single-pass walk, and a pattern with no empty-capable repetition is
unchanged in behaviour and in the memory it reserves.

Two cases stay divergent. Bounded repetitions are unrolled into copies with no
backward edge, so the rule has nothing to attach to:

```ruby
/(|a){2,3}b/.match("ab")[1]  # CRuby: "",  mruby: "a"
```

And CRuby keeps a loop running in a few shapes where an empty iteration
rewrote a capture, which this does not model:

```ruby
/(?:(?:a{1,3}|(c{0,2}){2,}){1,}|b{1,3})+/.match("ccab")[0]
# CRuby: "ccab",  mruby: "cca"
```

Patterns with a non-greedy quantifier run on `bt_match()` and are untouched.