Keep check=False lenient; reject only wrong-size stacked arrays

The shape guard added with the stacked-array support rejected every
array whose shape differed from the class's internal value shape when
check=False. That broke accepted equivalent forms: Twist3 from a 4x4
SE(3)/se(3) matrix, Twist2 from a 3x3 SE(2)/se(2) matrix, and
Quaternion from a non-4-vector array, all of which the class _import
methods deliberately accept unchecked.

Only reject when a matrix pose class (SE3, SO3, SE2, SO2) gets a 3D
array whose per-matrix size is wrong: such an array can only be read
as a stack, so the mismatch is never a valid pose, whatever check is.
Single 2D arrays keep their historical check=False behavior.

Author: RoboX2020

spatialmath/baseposelist.py

@@ -190,18 +190,19 @@ def arghandler(
             # it's a numpy array
 
             shape = tuple(self.shape)
-            if len(shape) == 2 and arg.ndim == 3 and arg.shape[1:] == shape:
+            if len(shape) == 2 and arg.ndim == 3:
+                # a 3D array passed to a matrix pose class is a stack
+                if arg.shape[1:] != shape:
+                    # a stack of matrices of the wrong size is rejected,
+                    # whatever the value of check
+                    return False
                 # a stacked (N, r, c) array is a sequence of N values
                 values = [self._import(x, check=check) for x in arg]
                 if any(x is None for x in values):
                     return False
                 self.data = values
                 return True
 
-            if not check and arg.shape != shape:
-                # check=False skips the value checks, but not the shape check
-                return False
-
             x = self._import(arg, check=check)
             if x is not None:
                 self.data = [x]