Align builtin iterator controls and callback lifetimes - #9699

Summary

Group builtin iterator controls and callback lifetimes in 817 changed production lines (+588/-229):

• Reuse typed argument binders and share map/zip strict conversion, iterator acquisition and mismatch handling. Convert strict before acquiring iterators, propagate setstate conversion errors and preserve nonstrict native exceptions.

• Retain constructor-owned raw inputs across conversion callbacks and share their cleanup instead of per-function parsing.

• Preserve filter subclasses in reduction and align filter result cleanup.

• Compare callable-iterator sentinels in CPython's order, latch callable StopIteration, and release exhausted callable/sentinel owners outside locks.

• Snapshot callable reduction state before tuple allocation. Release the temporary sentinel comparison owner before truth conversion, preserving reentrant finalizer behavior.

• Share generic sequence/reverse iterator state without holding locks across sequence callbacks, allocation or owner release. Match empty/reverse exhaustion, strict signed state conversion, exception clearing and reentrant live-versus-captured indices.

• Preserve the pinned CPython signed-wrap behavior and negative-index normalization when callbacks change the live forward index to the native maximum.

Nine production Rust files. No Python, Lib, tests, expected-failure markers or workflows changed. Shared list/tuple/range/itertools implementations are untouched.

The strict signed-size conversion now uses the same borrowed helper as #9701, avoiding duplicate conversion logic while preserving the original state argument through mutation. This companion has no dependency on the native iterator engine.

• Export reversed as its actual subclassable type, bind its constructor through shared argument metadata, and honor special-method None and sequence checks without binding getitem merely to check support.
• Reconstruct reductions through the actual iterator type. Forward weakproxy reversal to the referent's ordinary method rather than the builtin fallback, preserving instance overrides and dead-referent errors.

Reference and validation

Compared with CPython commit d220409a13b77de7a6c30abe16ea90db01528edc: builtin iterator controls and callable iterators.

9,416 bounded CPython/source-model assertions passed, with additional independent lifecycle/error oracles. Coverage includes strict conversion and mismatch precedence, repeated calls, native StopIteration subclass data, state reentry, subclass reduction, callable equality/truth callbacks, resource release and resurrection. These are reference/model checks, not execution of the Rust implementation.

Independent exact-source review passed after correcting two findings: tuple allocation while a callable state read guard was held, and sentinel ownership extending across a reentrant truth callback. Focused host-env/VM/stdlib threading cargo check, normal all-targets Clippy and ordinary commit hooks passed. Clippy emitted exactly four unchanged main-baseline diagnostics: one POSIX needless-collect and three ElementTree lints. Strict -D warnings remains blocked by that baseline; no warnings were suppressed.

Native RustPython execution was not performed. Full workspace/C-API suites and cross-platform runtime tests remain unrun. Hosted CI is required; no runtime expected failure is claimed resolved.

The generic sequence/reverse companion passed 16,003 further bounded CPython/source-model assertions and independent callback/finalizer probes. Independent review caught and corrected reentrant MAX wrapping and verified the final composition preserves the original map/zip/filter/callable code byte-for-byte. Reference: sequence iterators and reversed.

Remaining limits

• PyType::call retains separate init_args for ordinary type calls. The new cleanup order governs constructor-owned references/direct constructor paths; it does not establish complete ordinary-call finalizer parity while inherited object.init/FuncArgs still own those values.
• Generic iterator wrappers may already normalize user StopIteration subclasses before these consumers receive them. The patch preserves original native errors where they remain available.
• Zip's existing result allocation lacks CPython's cached tuple, so result identity/refcounts and partial-result finalizer timing remain different.
• Existing enumerate allocation-under-counter-lock behavior is unchanged. Reversed constructor raw argument ownership is retained through callbacks; inherited ordinary type-call init_args and shared binder teardown behavior remain outside this change.
• Shared binder diagnostics and existing cross-thread scheduling/allocation timing remain outside scope. Old ownership/layout PRs may need textual reconciliation.

The reversed constructor/proxy companion passed 86 bounded pinned-CPython assertions and independent source/lifecycle/metadata review. All generic iterator state mechanics remain unchanged by this companion.

AI-assisted contribution by OpenAI Codex, disclosed in the commit trailer.