Walk every container, so for loops run

[tamnd]

The lowering and the compiler already turned a for into a loop over GetIter, Next and Exhausted. The interpreter stubbed all three, and this fills them in.

The end of a walk is a value rather than an exception. CPython raises StopIteration there, which makes every for loop in the language an exception handler and makes every iteration pay a little towards the one that will not happen. Here Next writes a sentinel and Exhausted tests it, so a loop compiles to an ordinary test and branch. No Python program can obtain one, because nothing else constructs it and the only instruction that reads it is emitted immediately after the one that writes it. When generators arrive they raise StopIteration the way Python says and the runtime turns that back into this at the boundary.

An iterator holds the container and a position rather than a copy, which is what CPython does and is observable in both directions. A list that grows while it is being walked keeps the walk going, one that shrinks ends it early, and a dict or a set that changes size raises RuntimeError instead. The position into a dict is an index into the entry table rather than a count of live entries, so a deletion earlier in the table cannot silently shift what comes next. Strings are the one container walked from a copy, because the nth code point of UTF-8 is only reachable by counting from the front and stepping one that way would make walking a string quadratic.

range, len, iter and next came with it, since they all needed exactly this. A range is never built, so for i in range(1000000) is one object rather than a million, and it holds integers of any size rather than machine words. len now covers all six builtin containers plus range, which is what it was held back for, including len(range(2 ** 70)) raising OverflowError because a length has to fit in a machine word even when the range does not. A builtin now knows whether it is a function or a type, so print(range) says <class 'range'>.

Performance

The first version of the range walk computed the nth value from n, which is a multiply and a division on every step. for i in range(3000000): total += i cost 0.77s against CPython's 0.40s, and the same loop written with while cost 0.76s, so the counted loop was paying twice for its counting. Walking with a running value and one comparison brings it to roughly level with CPython. A proper interleaved measurement follows on the quiet machine.

Testing

Fifty new tests. Thirty three run whole programs and assert what a running CPython 3.14 prints for them, including every error message and the two places CPython does not agree with itself about them. Eight are unit tests over the range arithmetic, which is where the rounding is easy to get wrong in a way no program test would notice until the last element of some loop went missing.

Full gate green: cargo fmt, cargo test --workspace, cargo clippy --workspace --all-targets --all-features, cargo doc with warnings denied.

Part of #7.