It is initialized with what turns out to be '&PyBaseObject_Type', which
we can just use as is.

Note that we aren't storing it on the module state record yet, as that
triggers segfaults.

Requires overriding all the macros from 'cPersistence.h', most of which
(irony, anyone?) exist only for our benefit.

Still forced static, for now.

Prep for heap-allocating them.

- Use consistent naming, w/ '_type_def' suffix (for easy comparison
  with forthcoming '_type_spec' for heap-allocated types).

- Use named members, removing clutter.

- Move protocol specs (number, sequence, mepping) next to type definitions,
  to ease constructino of equivalent '_type_slots' for heap-allocated types.

- Add TODOs to locations outside module initialization which use the
  addresses of type defs:  they need to look them up on the module state.

Verses addresses of the static type defs.

Avoid segfault at application exit.

zope.testrunner doesn't need it, and it causes a ginormous warning
balloon under pytest

Callers must pass it the 'module', in order that it can find its type
from module state.

And make it a 'module method' like 'newBTreeItems'.

See: 2c55b0f

- Split out __name__ and __doc__ to static constants.
- Disentangle 'BTreeType_type_def' and its one method from 'BTree_type_def'
- Wrap the static structures with '#if USE_STATIC_TYPES', leaving an empty
  '#else..#endif' block beneath, where the heap allocated definitions will
  go.

Juggle tables between static and heap-alloc sections to ease verification
by the Mark 1 eyeball.

The 'SetIteration' type is used only privately, and doesn't go through
the whole type initialization dance.

Note that we may want to back this out for BTrees, and copy the
logic on 'BTreeType_setattro' to control which attributes are settable,
rather than using the 'BTreeType' metaclass in combination with
heap types, which limits us to Python >= 3.12.

Apply automatic formatting, via https://formatter.org/, then
re-apply changes to use module state.

Safeguarding against stray change I might've introduced when
reformatting those modules by hand.

If heap-allocated type.

- Multi-phase module initialization.
- Heap-allocated types.

The GC dance for buckets is still horked.

Avoids 'PyObject_New' FBO heap-allocated types, but works just as
well for the statid types.

And use its 'tp_alloc' slot, rather than calling it as an object.

Both faster and easier to reason about.

One exception is the call to create a new bucket for a tree, which
has to live with the promise made to respect the '_bucket_type' attribute
on derived classes.

Heap-allocated BTrees et. all still segfault.

Use static inlined versions, to placate compilers which don't allow
'foreign' function pointers in static initializers.

Their arguments cannot be guaranteed to be instances of our types,
which means we cannot use them to dead-reckon to the module.

All callers have, or can easily derive, the module anyway.

Ensure that we play nicely with 'Persistent', whether it is heap-allocated
or no.

Rather than dead-reckoning from types of args, make callers pass in
the module (they probably have it already at this point).

In prepration for dropping the others and renaming the '_from_module' ones

Takes either a module or a BTree-ish object, and returns the PerCAPI*.

Will replace both '_get_capi_struct' and '_get_capi_struct_from_module'.

…cessors.