feat: split rectangular adaptive meshes — Bilinear (rank-CDF) vs RTU (kernel-CDF)

Split the rectangular adaptive mesh family into two user-facing variants
(PyAutoArray#461):

- RectangularBilinearAdaptDensity / RectangularBilinearAdaptImage: the
  empirical rank-CDF lattice transform (sort + cumsum, no kernel
  hyperparameters), recovered from the pre-#402 implementation
  (22b2846^) as create_transforms_rank. O(N log N) on CPU — the fast
  workspace default, eliminating the O(M_sub x N_data) erf sum that
  dominates the numba CPU likelihood (55% euclid / 89% hst).
- RectangularRTUAdaptDensity / RectangularRTUAdaptImage: pure renames of
  the kernel-CDF classes (values unchanged) — the advanced option for
  GPU, JAX gradient samplers and the interferometer sparse path, where
  they remain the only adaptive rectangular meshes with usable gradients.
- RectangularUniform unchanged (now inherits the RTU name).

The transform seam is a `transform="rank"|"kernel"` selector threaded
through create_transforms dispatch, the adaptive_rectangular_* functions,
InterpolatorRectangular and MeshGeometryRectangular, so the geometry's
areas/edges always route through the same transform as the mapper. Both
transforms share the existing 4-pixel bilinear interpolation.

Docstrings encode the guidance split: gradient inference on the Bilinear
default needs over_sample_size_pixelization >= 4 (imaging); interferometer
gradient work needs RTU (certified in the July gradient audit).

Breaking rename — no back-compat aliases; downstream workspaces update in
follow-up PRs.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WtMqU3JfmyJh8GvB7jT4Et

Author: claude

autoarray/exc.py

@@ -72,7 +72,7 @@ class MeshException(Exception):
     """
     Raises exceptions associated with the `inversion/mesh` modules and `Mesh` classes.
 
-    For example if a `RectangularAdaptDensity` mesh has dimensions below 3x3.
+    For example if a `RectangularRTUAdaptDensity` mesh has dimensions below 3x3.
     """
 
     pass

autoarray/fixtures.py

@@ -368,7 +368,7 @@ def make_border_relocator_2d_7x7():
 
 def make_rectangular_mapper_7x7_3x3():
 
-    from autoarray.inversion.mesh.mesh.rectangular_adapt_density import (
+    from autoarray.inversion.mesh.mesh.rectangular_rtu_adapt_density import (
         overlay_grid_from,
     )
 

autoarray/inversion/inversion/abstract.py

@@ -174,8 +174,8 @@ def cls_list_from(self, cls: Type, cls_filtered: Optional[Type] = None) -> List:
 
         - If the input is `cls=aa.mesh.Mesh`, a list containing all pixelizations in the class are returned.
 
-        - If `cls=aa.mesh.Mesh` and `cls_filtered=aa.mesh.RectangularAdaptDensity`, a list of all pixelizations
-        excluding those which are `RectangularAdaptDensity` pixelizations will be returned.
+        - If `cls=aa.mesh.Mesh` and `cls_filtered=aa.mesh.RectangularRTUAdaptDensity`, a list of all pixelizations
+        excluding those which are `RectangularRTUAdaptDensity` pixelizations will be returned.
 
         Parameters
         ----------

autoarray/inversion/linear_obj/neighbors.py

@@ -4,14 +4,14 @@
 class Neighbors(np.ndarray):
     def __new__(cls, arr: np.ndarray, sizes: np.ndarray):
         """
-        Class packaging ndarrays describing the neighbors of every pixel in a mesh (e.g. `RectangularAdaptDensity`).
+        Class packaging ndarrays describing the neighbors of every pixel in a mesh (e.g. `RectangularRTUAdaptDensity`).
 
         The array `arr` contains the pixel indexes of the neighbors of every pixel. Its has shape [total_pixels,
         max_neighbors_in_single_pixel].
 
         The array `sizes` contains the number of neighbors of every pixel in the pixelixzation.
 
-        For example, for a 3x3 `RectangularAdaptDensity` grid:
+        For example, for a 3x3 `RectangularRTUAdaptDensity` grid:
 
         - `total_pixels=9` and `max_neighbors_in_single_pixel=4` (because the central pixel has 4 neighbors whereas
           edge / corner pixels have 3 and 2).

autoarray/inversion/mesh/interpolator/delaunay.py

@@ -786,10 +786,10 @@ def _mappings_sizes_weights(self):
         The `sub_slim_index` refers to the masked data sub-pixels and `pix_indexes` the pixelization pixel indexes,
         for example:
 
-        - `pix_indexes_for_sub_slim_index[0, 0] = 2`: The data's first (index 0) sub-pixel maps to the RectangularAdaptDensity
+        - `pix_indexes_for_sub_slim_index[0, 0] = 2`: The data's first (index 0) sub-pixel maps to the RectangularRTUAdaptDensity
         pixelization's third (index 2) pixel.
 
-        - `pix_indexes_for_sub_slim_index[2, 0] = 4`: The data's third (index 2) sub-pixel maps to the RectangularAdaptDensity
+        - `pix_indexes_for_sub_slim_index[2, 0] = 4`: The data's third (index 2) sub-pixel maps to the RectangularRTUAdaptDensity
         pixelization's fifth (index 4) pixel.
 
         The second dimension of the array `pix_indexes_for_sub_slim_index`, which is 0 in both examples above, is used