feat: modular HAL, Raylib backend, PBR shading, textures, 60 unit tests

- Replace hardcoded SDL3 windowing with IWindow/IInputState/Key abstractions
- Each render backend owns its window (Raylib GLFW, SDL3 for Vulkan)
- Raylib backend: DrawModelEx, custom GLSL shader with Fresnel, ACES
  tonemapping, gamma correction, hemisphere ambient
- Fix backface culling, mesh memory (NativeMemory.Alloc), texture loading
- Camera controllers use backend-agnostic Key enum (inverted yaw/strafe)
- Demo scene: 8 cubes, 7 spheres, torus knot OBJ with checker texture
- Extract ProceduralMesh + MeshMath from Program.cs to Engine.Graphics
- Vulkan backend deferred (compiles, untested, IWindow-compatible)
- 60 unit tests: ObjLoader, camera controllers, AiCommandProcessor,
  RenderBackendFactory, Timing, ProceduralMesh, MeshMath, Transform
- AGENTS.md for opencode integration

tests/Engine.Tests/MeshMathAndProceduralTests.cs

@@ -0,0 +1,119 @@
+using System.Numerics;
+using Engine.Core;
+using Engine.Graphics;
+
+namespace Engine.Tests;
+
+public class MeshMathTests
+{
+    [Fact]
+    public void Computes_Normal_For_CCW_Triangle()
+    {
+        var n = MeshMath.ComputeFaceNormal(
+            new Vector3(0, 0, 0),
+            new Vector3(1, 0, 0),
+            new Vector3(0, 1, 0));
+
+        Assert.Equal(0f, n.X, 0.001f);
+        Assert.Equal(0f, n.Y, 0.001f);
+        Assert.Equal(1f, n.Z, 0.001f);
+    }
+
+    [Fact]
+    public void Normal_Is_Unit_Length()
+    {
+        var n = MeshMath.ComputeFaceNormal(
+            new Vector3(0, 0, 0),
+            new Vector3(3, 0, 0),
+            new Vector3(0, 4, 0));
+
+        Assert.Equal(1f, n.Length(), 0.001f);
+    }
+
+    [Fact]
+    public void Degenerate_Triangle_Falls_Back_To_UnitY()
+    {
+        var n = MeshMath.ComputeFaceNormal(
+            new Vector3(0, 0, 0),
+            new Vector3(1, 0, 0),
+            new Vector3(2, 0, 0));
+
+        Assert.Equal(Vector3.UnitY, n);
+    }
+}
+
+public class ProceduralMeshTests
+{
+    [Fact]
+    public void Sphere_Has_Correct_Vertex_Count()
+    {
+        var mesh = ProceduralMesh.CreateSphere(1f, 16, 8, Vector3.One);
+
+        Assert.Equal((8 + 1) * (16 + 1), mesh.Vertices.Length);
+    }
+
+    [Fact]
+    public void Sphere_Has_Correct_Index_Count()
+    {
+        var mesh = ProceduralMesh.CreateSphere(1f, 16, 8, Vector3.One);
+
+        Assert.Equal(8 * 16 * 6, mesh.Indices.Length);
+    }
+
+    [Fact]
+    public void Sphere_Vertices_Lie_On_Surface()
+    {
+        const float radius = 2.5f;
+        var mesh = ProceduralMesh.CreateSphere(radius, 8, 4, Vector3.One);
+
+        foreach (var v in mesh.Vertices)
+            Assert.Equal(radius, v.Position.Length(), 0.001f);
+    }
+
+    [Fact]
+    public void Sphere_Normals_Are_Unit_Length()
+    {
+        var mesh = ProceduralMesh.CreateSphere(1f, 8, 4, Vector3.One);
+
+        foreach (var v in mesh.Vertices)
+            Assert.Equal(1f, v.Normal.Length(), 0.001f);
+    }
+
+    [Fact]
+    public void Sphere_Top_Pole_At_Positive_Y()
+    {
+        var mesh = ProceduralMesh.CreateSphere(1f, 8, 4, Vector3.One);
+
+        Assert.Equal(1f, mesh.Vertices[0].Position.Y, 0.001f);
+        Assert.Equal(0f, mesh.Vertices[0].Position.X, 0.001f);
+        Assert.Equal(0f, mesh.Vertices[0].Position.Z, 0.001f);
+    }
+
+    [Fact]
+    public void Grid_Has_Correct_Vertex_Count()
+    {
+        var mesh = ProceduralMesh.CreateGrid(5, 1f, Vector3.One);
+
+        var expectedLines = 2 * 5 + 1;
+        Assert.Equal(expectedLines * 4 * 2, mesh.Vertices.Length);
+    }
+
+    [Fact]
+    public void Grid_All_Normals_Point_Up()
+    {
+        var mesh = ProceduralMesh.CreateGrid(3, 1f, Vector3.One);
+
+        foreach (var v in mesh.Vertices)
+            Assert.Equal(Vector3.UnitY, v.Normal);
+    }
+
+    [Fact]
+    public void Grid_Extent_Matches_Lines_And_Spacing()
+    {
+        var mesh = ProceduralMesh.CreateGrid(10, 2f, Vector3.One);
+
+        var maxPos = 10f * 2f;
+        Assert.True(mesh.Vertices.Any(v => v.Position.X <= -maxPos));
+        Assert.True(mesh.Vertices.Any(v => v.Position.X >= maxPos));
+    }
+}