bindings/python: +feat Import transitions in bulk and document wrapper ownership

[Adda0]

Building an automaton from Python went one transition at a time through
Nfa.add_transition or Delta.add: one Python call, one argument conversion and
one sorted insertion per transition.

Delta gains two bulk entry points over the C++ batched import
Delta::add(std::vector&&): add_transitions(sources, symbols,
targets) taking three equal-length sequences, and add_transitions_from(triples)
taking an iterable of (source, symbol, target). Both convert and range-check the
whole input into C++ vectors before touching the delta, so invalid input raises
and leaves the automaton exactly as it was, and both release the GIL around the
native sort and build. The semantics match repeated add(): duplicates collapse,
states up to the largest mentioned one are allocated, and an import into a
non-empty delta merges.

Measured in this workspace, 200000 random transitions over 50000 states:
per-transition add_transition 120.5 ms, add_transitions 59.5 ms, a 2.02x
speedup, both producing identical automata. Peak RSS grows by 66 MB for the
per-transition loop and by 72 MB for the bulk import, which additionally holds
the three input sequences and the converted vector at the same time, so the
bulk path trades a little peak memory for half the time.

The two "TODO: Refactor into a generator" are resolved: iter_transitions_from(state)
streams the post of one state by reference, get_trans_from_state_as_sequence()
is a list of it, and iterate() is documented as the streaming form of
get_trans_as_sequence(). Return types are unchanged.

The ownership rules are now written down in the .pxd and .pyx docstrings and
each has a test: Nfa and Nft own the C++ automaton through a shared_ptr; a Delta
view holds an aliasing shared_ptr and keeps its automaton alive; the iteration
generators keep their owner alive; Transition, SymbolPost and Run own a raw heap
object.

The shared_ptr TODO in nfa.pxd is resolved by measurement rather than deleted
blindly: creating and dropping a Delta view costs 128 ns and a cheap method call
through thisptr.get() costs 82 ns, so the atomic reference count is not visible
next to the Python call overhead itself. The TODO is replaced by that number.

Left from #796 and not part of this commit: the Nft bulk import, which also has
to extend levels for new states (#763); the export/import round trip with
#755's transitions_as_arrays() and pickling, which do not exist on devel yet;
a lifetime test for noodle segments sharing one automaton; and a Python
benchmark kept in the repository. The figures above were not re-measured
after rebasing.

Part of #796.

Merge order: this PR is stacked on #883, which adds the C++ batched import
Delta::add(std::vector&&) it wraps. Merge #883 first; this PR's
base is #883's branch until then.