Add pyo3 module bridging to an embedded CPython - #6301

Add the rustpython-module_pyo3 crate, enabled by the new `pyo3` feature,
which provides the `pyo3` module:

- import_module() imports a CPython module.
- CPython objects appear as `pyo3.ref` proxies (`pyo3.callable_ref` for
  callables) forwarding attributes, calls, operators, comparisons, item
  access, iteration, hashing, buffers and the descriptor protocol.
- CPython classes appear as wrapper classes with the `pyo3.pyo3_type`
  metaclass. A class statement deriving from a wrapped class creates the
  class in CPython. CPython's built-in classes map to RustPython's.
- Immutable built-in values are copied both ways; list, dict, set,
  frozenset and bytearray are copied into CPython; buffers are shared both
  ways; RustPython callables and descriptors are proxied into CPython;
  other RustPython objects are pickled into CPython when possible and
  proxied otherwise.
- Exceptions become the nearest built-in exception class on the other
  side and come back as the original object.
- wraps runs a decorated function in CPython.

Uses pyo3 0.29.

Assisted-by: Claude Code:claude-opus-5-5

PyType::new_heap used bases[0] as the primary base. It now uses the base
best_base selects, the one with the most derived solid layout, so a plain
mixin listed before a base with a native layout no longer becomes the
primary base. solid_base and best_base no longer take a VirtualMachine.

Assisted-by: Claude
Assisted-by: Grok

A CPython instance now reaches RustPython as an instance of the wrapper
class of its CPython class, whose special methods come from the mirrored
class namespace, and a wrapper class's metaclass is the wrapper of the
CPython metaclass. pyo3.ref is the slot-less payload base of wrapper
classes; pyo3.proxy, with every protocol slot, remains for objects whose
class derives from a built-in layout.

A zero-dimensional CPython buffer spans its whole length.

Assisted-by: Claude
Assisted-by: Grok

The pyo3 module now initializes CPython itself with use_environment
disabled, so PYTHONHOME and PYTHONPATH meant for RustPython are not read
by it, and routes CPython's sys.unraisablehook to RustPython's while a
RustPython interpreter runs on the thread.

Wrapper classes support weak references when the CPython class does and
mirror the CPython __mro__. RustPython objects supporting the number
protocol get reverse proxies with the matching slots, and instances of
RustPython subclasses of built-in value types reach CPython as values of
that built-in type.

Assisted-by: Claude
Assisted-by: Grok

A str or bytes converted while calling into CPython is copied once per
call, and the copies live as long as the call's result instead of being
attached to ctypes objects through _objects. A RustPython buffer exported
to CPython is released when CPython releases its last view.

Classes created through a wrapped CPython metaclass, including through
its __call__, __new__ and __prepare__, are created in CPython.

Assisted-by: Claude
Assisted-by: Grok

A RustPython object passed to CPython gets a proxy class carrying exactly
the number slots its class defines: __index__, __float__, __complex__,
unary - + ~ abs, and the binary operators with their reflected forms. One
proxy class is cached per set of slots. pyo3.proxy defines __complex__.

The conversion docs state that list, dict, set and bytearray are copied
and that CPython's changes to the copy do not reach the original. Module
docs and comments are updated to the current behavior.

Assisted-by: Grok
Assisted-by: Claude

The method assigns a version tag under the type lock when the type has
none and returns the tag, or 0 when none can be assigned.

Assisted-by: Grok
Assisted-by: Claude

- copy.copy and copy.deepcopy of an embedded object run the embedded
  copy module. Pickling one stores the embedded pickle bytes behind
  pyo3.load_embedded.
- The wrapper of an immutable embedded metaclass whose metaclass is type
  has type as its metaclass and copies IMMUTABLETYPE; mutable ones keep
  forwarding through pyo3.pyo3_type.
- rustpython.object proxies publish the dunder methods the wrapped class
  defines, decided by the first defining class in the MRO and cached per
  class by version tag, and fill the sequence length slot.
- Embedded warnings are shown through this interpreter's warnings module
  while a RustPython interpreter runs on the thread, and warning
  categories map to the matching built-in classes.

Assisted-by: Grok
Assisted-by: Claude

pytest in extra_tests collected test_module_pyo3.py with the host
CPython and failed on `import pyo3`. The test now lives in
crates/module_pyo3/tests, and a new pyo3 job builds RustPython with the
pyo3 feature against CPython 3.14 from actions/setup-python and runs it
on Linux, macOS and Windows.

Assisted-by: Grok
Assisted-by: Claude