Close M0: headless CLI, JSON world dump, project-level plugin loading

The last piece of the agent loop from docs/kernel-contract.md §7:

- WorldDumper serializes a World to JSON — every GameObject, its
  transform, its components (arbitrary plugin-defined classes, so this
  leans on System.Text.Json's own reflection with IncludeFields=true,
  since components are public fields, not properties). Components are
  a list of {type, data}, not a dictionary keyed by type name:
  AddComponent<T>() doesn't enforce uniqueness, so a GameObject can
  carry two components of the same type, and a dictionary would throw
  on exactly that case — tested directly.
- PluginHost.LoadProject reads a project.json and resolves each
  referenced plugin id against engine + project-local search paths,
  finally putting ProjectManifest/PluginReference to use — they'd sat
  unused since the very first scaffold commit.
- Engine.Host is a real CLI now: `engine run --headless --plugins <dir>
  --project <project.json> --frames <n> [--dump <path>]`. --scene and
  --assert are explicitly rejected with a message pointing at why
  (no scene format yet — that's M2; no query DSL was ever actually
  specified for --assert, and jq over a plain JSON dump already covers
  that need), rather than silently ignored or generically rejected.
  Same for `engine diag why-pinned`: nothing has ever failed to unload
  in testing, so there's nothing to build that against yet.
- EchoPlugin now seeds one Ping-bearing GameObject in Configure() —
  sandbox.echo is documented as a test fixture, not a real subsystem,
  and there's no scene format yet to seed content any other way.

Verified by hand, not just by unit tests, since Program.cs itself
isn't covered by any: assembled a real flat plugin directory
(plugin.json + both built DLLs) and actually ran the CLI against
sandbox.echo end to end — 3 frames in, Ping.Count came back 3 in the
dump. Also checked every "not implemented" path (--scene, `diag`,
missing required args) prints its intended message rather than a
generic error.

32 tests total now (26 in Engine.Kernel.Tests, 6 in
Engine.ConformanceHarness), all green on a clean build.

README's Status section updated — M0 was the whole reason this
project exists (fast iteration without Unity's domain reload), and
that claim is no longer just architecture on paper.

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

src/Engine.Kernel/Diagnostics/WorldDumper.cs

@@ -0,0 +1,56 @@
+using System.Text.Json;
+using Engine.Kernel.World;
+
+namespace Engine.Kernel.Diagnostics;
+
+/// <summary>
+/// Serializes a World to JSON for the headless introspection loop described
+/// in docs/kernel-contract.md §7 — an agent's only way to see the effect of
+/// an edit without a screen. Read-only and outside any system's execution,
+/// so it isn't subject to SystemAccessScope enforcement.
+///
+/// Component types are arbitrary plugin-defined classes, so this leans on
+/// System.Text.Json's own reflection rather than anything bespoke —
+/// including IncludeFields, since components are plain public fields
+/// (docs/kernel-contract.md §1), not properties.
+/// </summary>
+public static class WorldDumper
+{
+    private static readonly JsonSerializerOptions Options = new()
+    {
+        WriteIndented = true,
+        IncludeFields = true,
+    };
+
+    public static string ToJson(IWorld world)
+    {
+        var roots = world.Roots.Select(Dump).ToList();
+        return JsonSerializer.Serialize(roots, Options);
+    }
+
+    private static object Dump(GameObject go) => new
+    {
+        name = go.Name,
+        transform = new
+        {
+            position = ToArray(go.Transform.LocalPosition),
+            rotation = new[]
+            {
+                go.Transform.LocalRotation.X, go.Transform.LocalRotation.Y,
+                go.Transform.LocalRotation.Z, go.Transform.LocalRotation.W,
+            },
+            scale = ToArray(go.Transform.LocalScale),
+        },
+        // A list, not a dictionary keyed by type name: AddComponent<T>()
+        // doesn't enforce uniqueness (see the World row in §2), so a
+        // GameObject can legitimately carry two components of the same
+        // type. A dictionary would throw on the very case this needs to
+        // represent correctly.
+        components = go.Components
+            .Select(c => new { type = c.GetType().Name, data = (object)c })
+            .ToList(),
+        children = go.Children.Select(Dump).ToList(),
+    };
+
+    private static float[] ToArray(System.Numerics.Vector3 v) => [v.X, v.Y, v.Z];
+}