feat(cad): adacpp builds CurveBoundedPlane; tessellate_shape backend-aware

- AdacppBackend.build() dispatches su.CurveBoundedPlane (plate/beam shell
  representation) to adacpp.cad.build_planar_face — native, no pythonocc.
- tessellate_shape() now dispatches on handle type itself: pythonocc TopoDS →
  rich ShapeTesselator; other handles → active backend's tessellate verb +
  computed normals. Fixes every tessellation entry (occ_geom_to_poly_mesh,
  shape_to_tri_mesh, BatchTessellator) under adacpp; removes the now-redundant
  _triangulate helper.

OccBackend unchanged (655 pass), ruff clean. Under adacpp, CurveBoundedPlane
build-failures resolved (remaining shell failures are the FEM-meshing TopExp
path, next).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: Krande

src/ada/cad/__init__.py

@@ -93,6 +93,7 @@ def build(self, geometry: "Geometry") -> ShapeHandle:
         # NotImplementedError rather than borrowing pythonocc. End goal: full
         # parity with OccBackend. See dap plan/v3 Phase 7.
         import ada.geom.solids as so
+        import ada.geom.surfaces as su
 
         g = geometry.geometry
 
@@ -114,8 +115,6 @@ def _axis(d, default):
             p = g.position
             shape = self._cad.build_cone(list(p.location), _axis(p.axis, (0, 0, 1)), g.bottom_radius, g.height)
         elif isinstance(g, so.ExtrudedAreaSolid):
-            import ada.geom.surfaces as su
-
             area = g.swept_area
             if not isinstance(area, su.ArbitraryProfileDef) or area.profile_type != su.ProfileType.AREA:
                 raise NotImplementedError(
@@ -129,6 +128,21 @@ def _axis(d, default):
                 outer, inners, self._xyz(p.location),
                 _axis(p.axis, (0, 0, 1)), _axis(p.ref_direction, (1, 0, 0)), g.depth,
             )
+        elif isinstance(g, su.CurveBoundedPlane):
+            import ada.geom.curves as cu
+
+            if not isinstance(g.outer_boundary, cu.IndexedPolyCurve):
+                raise NotImplementedError(
+                    f"AdacppBackend.build: CurveBoundedPlane outer_boundary "
+                    f"{type(g.outer_boundary).__name__!r} not yet ported to adacpp."
+                )
+            outer = self._encode_curve(g.outer_boundary)
+            inners = [self._encode_curve(c) for c in g.inner_boundaries]
+            pos = g.basis_surface.position
+            shape = self._cad.build_planar_face(
+                outer, inners, self._xyz(pos.location),
+                _axis(pos.axis, (0, 0, 1)), _axis(pos.ref_direction, (1, 0, 0)),
+            )
         else:
             raise NotImplementedError(
                 f"AdacppBackend.build: ada.geom type {type(g).__name__!r} is not yet ported to "

src/ada/occ/tessellating.py

@@ -82,6 +82,18 @@ def tessellate_advanced_face(face: TopoDS_Shape, linear_deflection=0.1, angular_
 
 
 def tessellate_shape(shape: TopoDS_Shape, quality=1.0, render_edges=False, parallel=True) -> TriangleMesh:
+    # Backend dispatch: a pythonocc TopoDS uses the rich ShapeTesselator
+    # (normals + edges). Any other handle (e.g. an adacpp ShapeHandle) is
+    # tessellated through the active backend's tessellate verb (adacpp's native
+    # ShapeTesselator port) and adapted to a TriangleMesh with computed normals.
+    if not isinstance(shape, TopoDS_Shape):
+        from ada.cad import active_backend
+
+        mesh = active_backend().tessellate(shape)
+        positions = np.ascontiguousarray(mesh.positions, dtype="float32")
+        faces = np.ascontiguousarray(mesh.indices, dtype="uint32")
+        return TriangleMesh(positions, faces, None, _vertex_normals(positions, faces))
+
     # first, compute the tesselation
     try:
         tess = ShapeTesselator(shape)
@@ -161,7 +173,7 @@ def tessellate_occ_geom(
             tess_shape = tessellate_edges(occ_geom)
             indices = tess_shape.indices
         else:
-            tess_shape = self._triangulate(occ_geom)
+            tess_shape = tessellate_shape(occ_geom, self.quality, self.render_edges, self.parallel)
             indices = tess_shape.faces
 
         mat_id = self.material_store.get(geom_color, None)
@@ -180,26 +192,6 @@ def tessellate_occ_geom(
             geom_ref,
         )
 
-    def _triangulate(self, occ_geom) -> TriangleMesh:
-        """Triangle-mesh a body. pythonocc TopoDS handles use the rich
-        ShapeTesselator (normals + edges). Any other handle (e.g. an adacpp
-        ShapeHandle) is tessellated through the active backend's tessellate
-        verb and adapted to a TriangleMesh — keeping the tessellation path
-        backend-independent. Normals are computed from the triangles since the
-        lean backend Mesh carries only positions + indices."""
-        from OCC.Core.TopoDS import TopoDS_Shape
-
-        if isinstance(occ_geom, TopoDS_Shape):
-            return tessellate_shape(occ_geom, self.quality, self.render_edges, self.parallel)
-
-        from ada.cad import active_backend
-
-        mesh = active_backend().tessellate(occ_geom)
-        positions = np.ascontiguousarray(mesh.positions, dtype="float32")
-        faces = np.ascontiguousarray(mesh.indices, dtype="uint32")
-        normals = _vertex_normals(positions, faces)
-        return TriangleMesh(positions, faces, None, normals)
-
     def tessellate_geom(
         self,
         geom: Geometry,