C API type slots - #8435

The tp_new slot holds a Rust fn pointer, which a C `newfunc` cannot be.
Put the C function in a `CSlots` table owned by the heap type it belongs
to, and store `c_new_trampoline` in `new`; the trampoline reads the table
off the type it is called with, so a subclass that inherited both reaches
the same function and passes itself as `subtype`.

`PyTypeSlots` holds one 8-byte pointer to the table rather than a field
per C-provided slot, so further slots are a field in `CSlots` and a
trampoline beside this one. The pointer is inherited with `new` by
`set_new` and by `update_one_slot`, and dropped when a Python-level
`__new__` replaces the slot.

Compare what tp_new dispatches to, not the slot, in the "is not safe"
check: every C type shares one trampoline, so comparing `new` alone let
`CBase.__new__(CSub)` run CSub's tp_new.

Move the C call marshalling from capi to `types::c_slots` so the
trampoline and the METH_* call paths share it.

Assisted-by: Claude

PyType_GetSlot reported Py_tp_new only for a function installed from C.
A Rust slot such as int's or object's read as NULL, so an extension that
reads its base type's tp_new to call it with its own subtype had nothing
to call.

Pair each Rust tp_new with a statically instantiated extern "C"
function. `c_new_for::<S>` marshals `(subtype, args, kwds)`, calls
`S::call`, and returns the object or NULL with the exception pending.
`S` is `ViaConstructor<T>` for a `#[pyclass(with(Constructor))]` payload
and `PythonNew` for `new_wrapper`; the target is fixed by the type
parameter, so a subtype passed in runs the base's body.

The derive macro emits a `HasStaticCSlots::TABLE` const per Constructor
class holding the (Rust fn, C fn) pair, and stores a reference to it in
the new `PyTypeSlots::static_c_slots` field on the defining type only.
`PyType::c_tp_new` resolves a C-installed slot from `CSlots`, and a Rust
slot by matching the slot's address against the tables along the MRO,
then against the `new_wrapper` pair.

An empty heap subclass of object now reports object's tp_new rather
than NULL; the round-trip test is updated for that.

Assisted-by: Claude
Assisted-by: Grok

Reproduce what pyo3's PyNativeTypeInitializer does: a heap type whose C
tp_new fetches the base type's tp_new through PyType_GetSlot and calls
it with the subtype it was given. Cover object and int as bases, a
Python-level subclass of the extension type, the slot each type reports,
and a ValueError raised by the base crossing both trampolines.

Replace a map/unwrap_or_else pair in a test helper that clippy flags.

Assisted-by: Claude
Assisted-by: Grok

… body

An extension built with the 3.15 API creates its types through
PyType_FromSlots and writes its per-instance data at the address
PyObject_GetTypeData returns. Neither existed, and an instance of a
heap type derived from object was always the zero-sized PyBaseObject,
so there was nowhere for that data to go.

Add PyCBody, an instance payload holding a zero-filled buffer of the
type's basicsize bytes, aligned to 16. generic_alloc builds one when
the class has a positive basicsize and PyBaseObject otherwise.

PyType_FromSlots reads the outer PySlot list (name, flags, inner slots,
extra_basicsize, basicsize) and the inner PyType_Slot list (base, new,
methods, dealloc, doc), creates the heap type with
basicsize = align_up(base.basicsize, 16) + extra_basicsize, honors
Py_TPFLAGS_BASETYPE from the spec, publishes the method defs, and
stores tp_new and tp_dealloc in the type's CSlots. tp_dealloc is
stored and returned by PyType_GetSlot but not called yet.

PyObject_GetTypeData returns body + align_up(base.basicsize, 16), and
PyType_GetTypeDataSize the matching size. PyType_Freeze is a stub that
reports success.

A pyo3 #[pyclass] with #[new] and a method now allocates through
Py::new, instantiates through a Python-level call, and answers a
method call; pyclass_tests.rs covers that end to end.

Assisted-by: Claude
Assisted-by: Grok

…dObjArgs

An extension's tp_dealloc was stored on the type but never called, so
the Rust value pyo3 keeps in the instance body was never dropped.

drop_slow now reads the class's CSlots: when a C tp_dealloc is set, it
runs __del__ and weakref clearing, untracks the object, and hands the
pointer to tp_dealloc, which frees the allocation through tp_free.
PyType_GetSlot answers Py_tp_free with rustpython_free unless the
extension stored its own; it releases the PyInner and the C body
without running __del__ again and without decref'ing the class, which
tp_dealloc does after tp_free returns. PyType_FromSlots also accepts
Py_tp_free and Py_tp_alloc (alloc is stored, not used).

PyObject_CallMethodObjArgs is added as a naked entry per ABI, since a
variadic definition is not available on stable Rust: Apple ARM64 reads
the tail from the stack, AAPCS64 from x2..x7 then the stack, x86_64
SysV from rdx..r9 then the stack, and Win64 from r8/r9 then the stack.
Other targets accept only the no-argument form.

pyclass_tests.rs now covers call_method0, a Python subclass of a
Drop that runs when the last reference goes from Rust or from Python.
A variadic test calls PyObject_CallMethodObjArgs with 0, 1 and 7
arguments through its C ABI.

Assisted-by: Claude
Assisted-by: Grok

Assisted-by: Grok:4.6

The end-to-end pyo3 test sat as a top-level test module in src/. Every
other test in this crate lives beside the code it exercises, and an
integration test under tests/ cannot link: the exported C symbols in
the rlib are not pulled into a separate test binary. Declare it as a
test submodule of object/pytype, which owns type creation.

Assisted-by: Claude