Phase 10A/10B Inc 0: build system, handle model, first module surface

Builds n3xd-ocp end to end and publishes 7.9.3.1.dev1 to the Gitea registry,
where it installs anonymously and passes its suite.

- occt/Dockerfile: OCCT 7.9.3 compiled once into a manylinux_2_28 builder
  image (base digest + tarball sha256 pinned), Draw/VTK/Tk/Xlib/OpenGL off,
  FreeType on, -O2 without fast-math or march=native. A final layer asserts
  TKService/TKV3d exist with no libGL/libX11 DT_NEEDED, which is what lets the
  app image drop libgl1/libx11-6. Mounted into, never built FROM.
- scikit-build-core + nanobind STABLE_ABI -> one cp312-abi3 extension that
  registers every OCP.* submodule via PyImport_AddModule, so `import
  OCP.TopoDS` needs no shim and cls.__module__ is right. Version <occt>.N is
  asserted against the OCCT found, keeping occt_version() truthful.
- occt_handle.h: type caster for opencascade::handle<T> over OCCT's intrusive
  refcount. Wrappers are non-owning instances holding exactly one handle in
  their keep-alive list, reusing an existing wrapper so identity survives a
  round trip. Transient constructors go through ocp_new (never nb::init<>,
  which would let OCCT delete nanobind's storage); the caster refuses a
  refcount-0 object rather than corrupt the heap. Verified under ASAN with no
  memory-safety errors, plus an RSS bound over 50k create/destroy cycles.
- Sub-shapes are returned by value everywhere, making the TShape lifetime class
  that segfaulted a process-global face memo unrepresentable.
- Standard_Failure derives RuntimeError, with ~20 concrete types dispatched on
  the dynamic OCCT type (cad_pool marshals failures home by type name).
- Inc 0 surface: gp subset, TopAbs, TopoDS (+ downcasts), TopExp, TopLoc,
  TopTools, BRep, BinTools, Poly, Standard. 34 of the app's 139 symbols.
- n3xd_ocp: additive APIs kept out of the OCP namespace so parity testing stays
  meaningful. bintools (shape <-> bytes, GIL-free, byte-identical) and _debug.

Two findings worth the record, both verified against the stock wheel rather
than assumed: upstream binds __hash__ but leaves __eq__ at identity, which is
exactly what geom_memo.py's hash-bucket + IsSame scan is built around, so we
match it instead of "fixing" it; and BinTools can release the GIL after all, by
slurping the file-like object instead of bridging a streambuf that would call
back into Python.

Gate: BREP round-trips are byte-identical to cadquery-ocp-novtk across six
fixtures (the generator asserts stock idempotency first). That matters beyond
IPC — derive.py content-addresses BREP payloads by sha256 and stores the ref.

tests/test_forksafety.py

@@ -0,0 +1,59 @@
+"""Fork safety — what keeps cad_pool's forkserver cheap.
+
+cad_pool preloads the OCP-importing modules into a forkserver and forks per
+job (~30 ms) instead of spawning and re-importing OCCT (~1.3 s).  That is only
+sound if importing this binding starts no threads and leaves no state that a
+fork would invalidate.
+"""
+
+from __future__ import annotations
+
+import multiprocessing
+import threading
+
+
+def test_no_threads_after_import():
+    import OCP  # noqa: F401
+
+    assert threading.active_count() == 1, threading.enumerate()
+
+
+def _child(conn):
+    # Runs after the fork: exercise the kernel to prove the inherited image is
+    # usable rather than merely present.
+    import io
+
+    from OCP.BinTools import BinTools
+    from OCP.TopAbs import TopAbs_FACE
+    from OCP.TopExp import TopExp
+    from OCP.TopoDS import TopoDS_Shape
+    from OCP.TopTools import TopTools_IndexedMapOfShape
+
+    from .conftest import DATA
+
+    shape = TopoDS_Shape()
+    BinTools.Read_s(shape, io.BytesIO((DATA / "fused.brep").read_bytes()))
+    faces = TopTools_IndexedMapOfShape()
+    TopExp.MapShapes_s(shape, TopAbs_FACE, faces)
+
+    out = io.BytesIO()
+    BinTools.Write_s(shape, out)
+    conn.send((faces.Extent(), len(out.getvalue())))
+    conn.close()
+
+
+def test_forkserver_child_can_use_the_kernel():
+    import OCP  # noqa: F401
+
+    ctx = multiprocessing.get_context("forkserver")
+    ctx.set_forkserver_preload(["OCP", "OCP.TopoDS", "OCP.BinTools"])
+
+    parent, child = ctx.Pipe()
+    proc = ctx.Process(target=_child, args=(child,))
+    proc.start()
+    faces, size = parent.recv()
+    proc.join(30)
+
+    assert proc.exitcode == 0
+    assert faces == 12
+    assert size > 0