Vendor every dependency, so no build fetches the host's validator (hq to-be 45 D1)

The controller imports mesh-host/validate through a replace onto the forge
that holds it, and every build — the build agent's go build in a fresh
toolchain container, the Dockerfile's go mod download — would have fetched
it through the public proxy and checksum database at build time: a merge
breaking main on the network, the class Phase 1 removes. vendor/ is
committed; go builds from it with nothing fetched, and refuses to build
when it and go.mod disagree, so a pin moved without go mod vendor fails at
once. The Dockerfile copies vendor/ and builds with GOPROXY=off.

vendor/github.com/novox/mesh-host/validate/validate.go

@@ -0,0 +1,38 @@
+// Package validate is the node-engine's own judgement of a declaration, for whoever must know before
+// a declaration is sent whether a machine would take it (novox/hq to-be 45 §4, D1; §9, the merge gate).
+//
+// **One validator.** The controller composed declarations the host then refused whole — a manifest
+// the catalogue check passed (novox/hq issue 236), a consumer's identity too long for the machine's
+// names (issue 263) — because the only validator was the one the host runs as it applies. A second,
+// written in the controller from the host's rules, would drift from them the first time either
+// changed. So the host's own parsing is exported here, unchanged: what the controller's self-check and
+// the merge gate run is what every machine runs.
+//
+// It judges a declaration as it arrives over the link: actions are refused, as the host refuses them
+// from the link (novox/hq ADR 0005). Nothing here touches a machine.
+package validate
+
+import (
+	"errors"
+
+	"github.com/novox/mesh-host/internal/declaration"
+)
+
+// Declaration is every problem the node-engine would refuse a declaration for, each in its own words;
+// nil when it would take it. The body is the declaration as the controller composes it — the bytes a
+// signature is made over — not the signed envelope.
+func Declaration(raw []byte) []string {
+	_, err := declaration.Parse(raw)
+	if err == nil {
+		return nil
+	}
+	var refused *declaration.RefusalError
+	if errors.As(err, &refused) {
+		return refused.Problems
+	}
+	return []string{err.Error()}
+}
+
+// Version is the declaration vocabulary this validator speaks: a declaration of another version is
+// refused whole by Declaration, as by the host.
+const Version = declaration.Version