feat(groove/ipv6t): GRV6 frame implementation + 10 passing tests on [::1]

reference/ipv6t/ — complete IPv6T implementation:

src/grv6.zig (~350 lines):
  - FrameHeader: 108-byte packed struct, zero-copy readable via @ptrCast
  - FrameWriter: constructs GRV6 frames with type hash, cap hash,
    provenance chain. Maintains chain state across frames.
  - FrameReader: detects GRV6 magic, parses header, validates type hash
    against expected types, returns untyped for non-GRV6 traffic
  - computeTypeHash/computeCapHash: SHA-256 of A2ML type signatures
  - computeProvHash: SHA-256 chain linking type+cap+timestamp+payload+prev
  - Trust level derivation from flags (declared/attested/proven)
  - hashToHex utility for logging

test/grv6_test.zig — 10 tests, all passing:
  1. Positive: correct type hash accepted (dual-panel on [::1])
  2. Negative: wrong type hash rejected before payload parsing
  3. Provenance: 3 chained frames produce verifiable unique hashes
  4. Fallback: raw bytes without GRV6 magic treated as untyped
  5. Trust flag: PROVEN flag does not bypass type hash validation
  6. Header size is exactly 108 bytes
  7. Hash determinism: same input always produces same hash
  8. Multiple type acceptance: reader accepts any of N expected types
  9. Trust level correctly derived from flags
  10. Hash hex formatting is correct

Tests run two panel instances on [::1] (IPv6 loopback), exchanging
GRV6 frames over standard TCP. The bytes are identical to what would
traverse the internet — localhost TCP = WAN TCP from the application's
perspective.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: hyperpolymath

groove-protocol/reference/ipv6t/build.zig

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
+// Copyright (c) 2026 Jonathan D.A. Jewell (hyperpolymath)
+
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    // Create root module for the library
+    const lib_mod = b.createModule(.{
+        .root_source_file = b.path("src/grv6.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    // Library
+    const lib = b.addLibrary(.{
+        .name = "grv6",
+        .root_module = lib_mod,
+    });
+    b.installArtifact(lib);
+
+    // Create test module with grv6 as import
+    const test_mod = b.createModule(.{
+        .root_source_file = b.path("test/grv6_test.zig"),
+        .target = target,
+        .optimize = optimize,
+        .imports = &.{
+            .{ .name = "grv6", .module = lib_mod },
+        },
+    });
+
+    // Tests
+    const tests = b.addTest(.{
+        .root_module = test_mod,
+    });
+    const run_tests = b.addRunArtifact(tests);
+    const test_step = b.step("test", "Run GRV6 frame tests");
+    test_step.dependOn(&run_tests.step);
+}