Hold the owner of a borrowed GraphBLAS handle in TypedOpBase - #587

The pool stopped at psg 10.3.1.0, so CI installed nothing newer except on
the draw that picks "latest", which does not pin and so never produces a
reproducible combination. Three releases have landed since, and each carries
a SuiteSparse:GraphBLAS this project has to work against: 10.4.0 moved a
field in the matrix struct, and 10.5.0 dropped the post-build iso check that
four tests used to rely on.

psg 10.5.0.0 is on PyPI and, since 2026-08-26, on conda-forge, so the
conda-forge, wheel and source draws all cover it.

`scripts/check_versions.sh` tracks the newest version we test, so its psg
floor moves with the pool.

Only the psg pools change here. The other pools are revised further up this
branch stack, so raising them belongs there rather than in a commit that
would conflict with every rebase.

`SelectOp._from_indexunary` reuses the IndexUnaryOp's `GrB_IndexUnaryOp`
rather than allocating a second one, and marked the borrowing typed op
`_owns_gb_obj_inst = False` so that only one side would free it. Nothing
kept the owner alive, though: `register_anonymous` drops the IndexUnaryOp
on the way out, so its typed op is collected and frees the handle while the
SelectOp is still pointing at it.

The result is a dangling pointer rather than a NULL one. `__del__` frees
through a synthesized cell, `ffi.new(f"{c_type_name}*", gb_obj)`, so
`GrB_*_free` clears that temporary and leaves the op's own `gb_obj` holding
the old address.

Reproduced at 6f1eb02:

    def _ne_thunk(x, i, j, thunk):
        return x != thunk
    sel = SelectOp.register_anonymous(_ne_thunk)
    gc.collect()
    Vector.from_coo([0, 1, 2], [1, 5, 9]).select(sel, 5).new()
    -> UninitializedObject

Whether it raises depends on whether anything happens to retain the
IndexUnaryOp. With `x > thunk` it survives, because a traceback caught
inside the per-dtype compile loop keeps a frame that references it.

Replace the per-instance opt-out with `_gb_obj_owner`, naming the owning
typed op. That suppresses our free and keeps the handle alive for as long
as we can reach it; disclaiming ownership without naming an owner is what
left the handle dangling. The opt-out being replaced was added in 6f1eb02
to stop a double free, so the sequence is leak, double free, opt-out,
dangling handle, and now an owned reference.