Raise clearer errors for constructor, mask, and attribute misuse - #606

A Vector mask on a full-Matrix operation (ewise, extract, .new) leaked a raw
cffi error, "initializer for ctype 'struct GB_Matrix_opaque'", which says
nothing about masks.  The Vector-output direction was already guarded;
_check_mask now guards the Matrix-output direction the same way and reports
"Mask object must be type Matrix; got ...".

The check is gated behind a strict_kind flag rather than applied everywhere,
because assignment is a genuine exception: a Vector mask on a Matrix
row/column assign is valid, and Matrix.__setitem__ validates it separately.
So strict_kind is False for __setitem__ updates and True for .new() and other
full-tensor operations.

Two common misuses failed with a bare "no attribute" message that gave no
direction:

    A.new()           is the expression resolver, not an instance method
    A.transpose()     transpose is the .T property, not a method

A __getattr__ on BaseType supplies the hint on the attribute miss.  It
raises AttributeError, exactly as before, so hasattr() and getattr() with a
default keep answering the way they did and duck-typing probes are
unaffected; only the message changes.  Names with no hint keep the plain
message.

.new and .transpose ride in one commit because they are one mechanism: a
single __getattr__ consulting a single hint table.  Splitting them would mean
adding the same function twice.

__getattr__ fires only on a genuine attribute miss, since slots and methods
resolve first, so the attribute hot path is untouched.

There is deliberately no class-level hint (Matrix.new): that needs a
metaclass, and both candidates break something real.  A plain type
metaclass makes mixing Matrix into any abc-based class die with
"metaclass conflict", and an ABCMeta-derived one leaks register,
__abstractmethods__ and _abc_impl into dir(Matrix), which the
expression-surface guard rightly reports as drift.  Class-level misuse
keeps Python's default AttributeError, and test_abc_mixin_subclass pins
the abc composition.

test_abc_mixin_subclass checked only issubclass, so the subclass's
__len__ never ran. Make an instance and check that it is a Sized whose
len is its nvals, 0 and then 2 after two stores (a __len__ that returned
a constant would fail): the subclass must work as a Matrix and as the
abc, not just be declared.

Behavior fix; main has it. The repr's info row picks the storage format
with get_format(matrix) for a Matrix and from matrix._matrix for a
TransposedMatrix, and it chose with type(matrix) is Matrix. Any subclass
of Matrix took the TransposedMatrix branch, so on the suitesparse backend
repr() and _repr_html_() raised AttributeError: 'Sub' object has no
attribute '_matrix', for a plain subclass as for one with an abc mixin,
and so did the reprs of its masks (A.S, ~A.V). Choose with
_is_transposed, which Matrix and TransposedMatrix both define. The test
checks that the repr and HTML repr of a subclass and of its structural
and complemented value masks are a Matrix's but for the type's name, and
that its .T is a TransposedMatrix whose reprs match a Matrix's .T; it
fails before this with the AttributeError.

Behavior fix; main has it. check_status takes an error's text from
GrB_<type name>_error, with the type's own name, and a subclass of
Matrix or Vector has no such function. Any failing call on one, for
example on a subclass instance whose data was exported with
give_ownership=True, raised the right exception with check_status's
fallback text, "Unable to get the error string for type SubMatrix. This
is most likely a bug in graphblas. Please report this as an issue".

A class without an error function of its own now uses that of the
nearest base class in its MRO that has one. Only classes in
graphblas.core count, which is where all eleven such types are: a user's
mixin may share a GraphBLAS type's name, and listed first (a class
Context mixed into a Vector) it would hand GxB_Context_error a
GrB_Vector, which cffi rejects with a raw TypeError. A class with an
error function of its own keeps it, and TransposedMatrix, which does not
derive from Matrix, keeps the fallback. Two of graphblas's own classes
change besides subclasses, for the better: BuiltinDescriptor and
GlobalContext now get their C types' error text (Descriptor, Context)
instead of the fallback. The test makes a failing call on a given-away
subclass of Matrix, of Vector, and of Vector with such a Context mixin
listed first, and checks the text is the base class's; it fails before
this with the fallback text, and the mixin case with the TypeError
without the graphblas.core filter.

Behavior fix; main has it. A TransposedMatrix shares Matrix.wait and
Matrix._nvals, so when one of those calls failed, check_status was handed
the TransposedMatrix and looked for GrB_TransposedMatrix_error, which
GraphBLAS does not have. On a Matrix whose data was exported with
give_ownership=True, A.T.wait() and repr(A.T) raised NullPointer with
check_status's fallback text, "Unable to get the error string for type
TransposedMatrix. This is most likely a bug in graphblas. Please report
this as an issue", the same kind of message the previous commit fixed
for subclasses.

TransposedMatrix now gives its Matrix as _exc_arg, which check_status
already uses in place of the object it is handed (as for _MatrixArray),
so the error and its text are the Matrix's. The test checks that both
calls raise NullPointer with A.wait()'s text; it fails before this with
the fallback text.

With a TransposedMatrix now reporting against its Matrix, every object a
failing call can hand check_status is a Matrix, Vector, Scalar,
Descriptor or Context, or a subclass of one, so _error_type_name always
finds a base with an error function. A graphblas.core class without one
is passed over only for BuiltinDescriptor and GlobalContext, whose calls
cannot fail: the global context engages and disengages any number of
times, and builtin descriptors are never freed. Mark the skip and the
no-match return "defensive", and say why in a comment.