feat(kcsolve): add to_dict()/from_dict() JSON serialization for all types

Phase 3a of the solver server integration: add dict/JSON serialization
to all KCSolve pybind11 types so SolveContext and SolveResult can be
transported as JSON between the Create client, Silo server, and solver
runners.

Implementation:
- Constexpr enum string mapping tables for all 5 enums (BaseJointKind,
  SolveStatus, DiagnosticKind, MotionKind, LimitKind) with template
  bidirectional lookup helpers
- File-local to_dict/from_dict conversion functions for all 10 types
  (Transform, Part, Constraint::Limit, Constraint, MotionDef,
  SimulationParams, SolveContext, ConstraintDiagnostic,
  SolveResult::PartResult, SolveResult)
- .def("to_dict") and .def_static("from_dict") on every py::class_<>
  binding chain

Serialization details per SOLVER.md §3:
- SolveContext.to_dict() includes api_version field
- SolveContext.from_dict() validates api_version, raises ValueError on
  mismatch
- Enums serialize as strings matching pybind11 .value() names
- Transform: {position: [x,y,z], quaternion: [w,x,y,z]}
- Optional simulation serializes as None/null
- Pure pybind11 py::dict construction, no new dependencies

Tests: 16 new tests in TestKCSolveSerialization covering round-trips for
all types, all 24 BaseJointKind values, all 4 SolveStatus values,
json.dumps/loads stdlib round-trip, and error cases (missing key,
invalid enum, bad array length, wrong api_version).

src/Mod/Assembly/AssemblyTests/TestKCSolvePy.py

@@ -149,6 +149,289 @@ class TestKCSolveRegistry(unittest.TestCase):
         self.assertEqual(kcsolve.get_default(), original)
 
 
+class TestKCSolveSerialization(unittest.TestCase):
+    """Verify to_dict() / from_dict() round-trip on all KCSolve types."""
+
+    def test_transform_round_trip(self):
+        import kcsolve
+
+        t = kcsolve.Transform()
+        t.position = [1.0, 2.0, 3.0]
+        t.quaternion = [0.5, 0.5, 0.5, 0.5]
+        d = t.to_dict()
+        self.assertEqual(list(d["position"]), [1.0, 2.0, 3.0])
+        self.assertEqual(list(d["quaternion"]), [0.5, 0.5, 0.5, 0.5])
+        t2 = kcsolve.Transform.from_dict(d)
+        self.assertEqual(list(t2.position), [1.0, 2.0, 3.0])
+        self.assertEqual(list(t2.quaternion), [0.5, 0.5, 0.5, 0.5])
+
+    def test_transform_identity_round_trip(self):
+        import kcsolve
+
+        t = kcsolve.Transform.identity()
+        t2 = kcsolve.Transform.from_dict(t.to_dict())
+        self.assertEqual(list(t2.position), [0.0, 0.0, 0.0])
+        self.assertEqual(list(t2.quaternion), [1.0, 0.0, 0.0, 0.0])
+
+    def test_part_round_trip(self):
+        import kcsolve
+
+        p = kcsolve.Part()
+        p.id = "box"
+        p.mass = 2.5
+        p.grounded = True
+        p.placement = kcsolve.Transform.identity()
+        d = p.to_dict()
+        self.assertEqual(d["id"], "box")
+        self.assertAlmostEqual(d["mass"], 2.5)
+        self.assertTrue(d["grounded"])
+        p2 = kcsolve.Part.from_dict(d)
+        self.assertEqual(p2.id, "box")
+        self.assertAlmostEqual(p2.mass, 2.5)
+        self.assertTrue(p2.grounded)
+
+    def test_constraint_with_limits_round_trip(self):
+        import kcsolve
+
+        c = kcsolve.Constraint()
+        c.id = "Joint001"
+        c.part_i = "part1"
+        c.part_j = "part2"
+        c.type = kcsolve.BaseJointKind.Revolute
+        c.params = [1.5, 2.5]
+        lim = kcsolve.Constraint.Limit()
+        lim.kind = kcsolve.LimitKind.RotationMin
+        lim.value = -3.14
+        lim.tolerance = 0.01
+        c.limits = [lim]
+        d = c.to_dict()
+        self.assertEqual(d["type"], "Revolute")
+        self.assertEqual(len(d["limits"]), 1)
+        self.assertEqual(d["limits"][0]["kind"], "RotationMin")
+        c2 = kcsolve.Constraint.from_dict(d)
+        self.assertEqual(c2.type, kcsolve.BaseJointKind.Revolute)
+        self.assertEqual(len(c2.limits), 1)
+        self.assertEqual(c2.limits[0].kind, kcsolve.LimitKind.RotationMin)
+        self.assertAlmostEqual(c2.limits[0].value, -3.14)
+
+    def test_solve_context_full_round_trip(self):
+        import kcsolve
+
+        ctx = kcsolve.SolveContext()
+        p = kcsolve.Part()
+        p.id = "box"
+        p.grounded = True
+        ctx.parts = [p]
+
+        c = kcsolve.Constraint()
+        c.id = "J1"
+        c.part_i = "box"
+        c.part_j = "cyl"
+        c.type = kcsolve.BaseJointKind.Fixed
+        ctx.constraints = [c]
+        ctx.bundle_fixed = True
+
+        d = ctx.to_dict()
+        self.assertEqual(d["api_version"], kcsolve.API_VERSION_MAJOR)
+        self.assertEqual(len(d["parts"]), 1)
+        self.assertEqual(len(d["constraints"]), 1)
+        self.assertTrue(d["bundle_fixed"])
+
+        ctx2 = kcsolve.SolveContext.from_dict(d)
+        self.assertEqual(ctx2.parts[0].id, "box")
+        self.assertTrue(ctx2.parts[0].grounded)
+        self.assertEqual(ctx2.constraints[0].type, kcsolve.BaseJointKind.Fixed)
+        self.assertTrue(ctx2.bundle_fixed)
+
+    def test_solve_context_with_simulation(self):
+        import kcsolve
+
+        ctx = kcsolve.SolveContext()
+        ctx.parts = []
+        ctx.constraints = []
+        sim = kcsolve.SimulationParams()
+        sim.t_start = 0.0
+        sim.t_end = 10.0
+        sim.h_out = 0.01
+        ctx.simulation = sim
+        d = ctx.to_dict()
+        self.assertIsNotNone(d["simulation"])
+        self.assertAlmostEqual(d["simulation"]["t_end"], 10.0)
+        ctx2 = kcsolve.SolveContext.from_dict(d)
+        self.assertIsNotNone(ctx2.simulation)
+        self.assertAlmostEqual(ctx2.simulation.t_end, 10.0)
+
+    def test_solve_context_simulation_null(self):
+        import kcsolve
+
+        ctx = kcsolve.SolveContext()
+        ctx.parts = []
+        ctx.constraints = []
+        ctx.simulation = None
+        d = ctx.to_dict()
+        self.assertIsNone(d["simulation"])
+        ctx2 = kcsolve.SolveContext.from_dict(d)
+        self.assertIsNone(ctx2.simulation)
+
+    def test_solve_result_round_trip(self):
+        import kcsolve
+
+        r = kcsolve.SolveResult()
+        r.status = kcsolve.SolveStatus.Success
+        r.dof = 6
+        pr = kcsolve.SolveResult.PartResult()
+        pr.id = "box"
+        pr.placement = kcsolve.Transform.identity()
+        r.placements = [pr]
+        diag = kcsolve.ConstraintDiagnostic()
+        diag.constraint_id = "J1"
+        diag.kind = kcsolve.DiagnosticKind.Redundant
+        diag.detail = "over-constrained"
+        r.diagnostics = [diag]
+        r.num_frames = 100
+
+        d = r.to_dict()
+        self.assertEqual(d["status"], "Success")
+        self.assertEqual(d["dof"], 6)
+        self.assertEqual(d["num_frames"], 100)
+        self.assertEqual(len(d["placements"]), 1)
+        self.assertEqual(len(d["diagnostics"]), 1)
+
+        r2 = kcsolve.SolveResult.from_dict(d)
+        self.assertEqual(r2.status, kcsolve.SolveStatus.Success)
+        self.assertEqual(r2.dof, 6)
+        self.assertEqual(r2.num_frames, 100)
+        self.assertEqual(r2.placements[0].id, "box")
+        self.assertEqual(r2.diagnostics[0].kind, kcsolve.DiagnosticKind.Redundant)
+
+    def test_motion_def_round_trip(self):
+        import kcsolve
+
+        m = kcsolve.MotionDef()
+        m.kind = kcsolve.MotionKind.Rotational
+        m.joint_id = "J1"
+        m.marker_i = "part1"
+        m.marker_j = "part2"
+        m.rotation_expr = "2*pi*time"
+        m.translation_expr = ""
+        d = m.to_dict()
+        self.assertEqual(d["kind"], "Rotational")
+        self.assertEqual(d["joint_id"], "J1")
+        m2 = kcsolve.MotionDef.from_dict(d)
+        self.assertEqual(m2.kind, kcsolve.MotionKind.Rotational)
+        self.assertEqual(m2.rotation_expr, "2*pi*time")
+
+    def test_all_base_joint_kinds_round_trip(self):
+        import kcsolve
+
+        all_kinds = [
+            "Coincident",
+            "PointOnLine",
+            "PointInPlane",
+            "Concentric",
+            "Tangent",
+            "Planar",
+            "LineInPlane",
+            "Parallel",
+            "Perpendicular",
+            "Angle",
+            "Fixed",
+            "Revolute",
+            "Cylindrical",
+            "Slider",
+            "Ball",
+            "Screw",
+            "Universal",
+            "Gear",
+            "RackPinion",
+            "Cam",
+            "Slot",
+            "DistancePointPoint",
+            "DistanceCylSph",
+            "Custom",
+        ]
+        for name in all_kinds:
+            c = kcsolve.Constraint()
+            c.id = "test"
+            c.part_i = "a"
+            c.part_j = "b"
+            c.type = getattr(kcsolve.BaseJointKind, name)
+            d = c.to_dict()
+            self.assertEqual(d["type"], name)
+            c2 = kcsolve.Constraint.from_dict(d)
+            self.assertEqual(c2.type, getattr(kcsolve.BaseJointKind, name))
+
+    def test_all_solve_statuses_round_trip(self):
+        import kcsolve
+
+        for name in ("Success", "Failed", "InvalidFlip", "NoGroundedParts"):
+            r = kcsolve.SolveResult()
+            r.status = getattr(kcsolve.SolveStatus, name)
+            d = r.to_dict()
+            self.assertEqual(d["status"], name)
+            r2 = kcsolve.SolveResult.from_dict(d)
+            self.assertEqual(r2.status, getattr(kcsolve.SolveStatus, name))
+
+    def test_json_stdlib_round_trip(self):
+        import json
+
+        import kcsolve
+
+        ctx = kcsolve.SolveContext()
+        p = kcsolve.Part()
+        p.id = "box"
+        p.grounded = True
+        ctx.parts = [p]
+        ctx.constraints = []
+        d = ctx.to_dict()
+        json_str = json.dumps(d)
+        d2 = json.loads(json_str)
+        ctx2 = kcsolve.SolveContext.from_dict(d2)
+        self.assertEqual(ctx2.parts[0].id, "box")
+
+    def test_from_dict_missing_required_key(self):
+        import kcsolve
+
+        with self.assertRaises(KeyError):
+            kcsolve.Part.from_dict({"mass": 1.0, "grounded": False})
+
+    def test_from_dict_invalid_enum_string(self):
+        import kcsolve
+
+        d = {
+            "id": "J1",
+            "part_i": "a",
+            "part_j": "b",
+            "type": "Bogus",
+            "marker_i": {"position": [0, 0, 0], "quaternion": [1, 0, 0, 0]},
+            "marker_j": {"position": [0, 0, 0], "quaternion": [1, 0, 0, 0]},
+        }
+        with self.assertRaises(ValueError):
+            kcsolve.Constraint.from_dict(d)
+
+    def test_from_dict_bad_position_length(self):
+        import kcsolve
+
+        with self.assertRaises(ValueError):
+            kcsolve.Transform.from_dict(
+                {
+                    "position": [1.0, 2.0],
+                    "quaternion": [1, 0, 0, 0],
+                }
+            )
+
+    def test_from_dict_bad_api_version(self):
+        import kcsolve
+
+        d = {
+            "api_version": 99,
+            "parts": [],
+            "constraints": [],
+        }
+        with self.assertRaises(ValueError):
+            kcsolve.SolveContext.from_dict(d)
+
+
 class TestPySolver(unittest.TestCase):
     """Verify Python IKCSolver subclassing and registration."""