A build is work submitted to a role, on both buses

ADR 0121 carried through to working code. `Builders` is the asking side and
`BuildMachine` the taking side, each with an implementation per bus, and the builder
binary and the `build` command now go through them.

On the bus being built, one publish does what two did. The old bus answered the asker
through a reply queue and announced to an events exchange, because two audiences meant
two topologies. Here the outcome is the role's own event: the asker matches it by the
id its request carried, the controller records it, the catalogue places it in the graph.
So a build machine publishes once, needs a reply queue for nothing, and needs a grant
over nobody's inbox — which is what ruled out the alternatives.

The outcome carries the module name now. Only the manifest says what was built, and on
the old bus the separate announcement carried it; with one message for three readers it
belongs in the result. A failed build names none, because it produced no module version
and the catalogue would otherwise place something that was never made.

Checked against a real server: the whole round trip; a third party on the role's event
hearing the same outcome the asker did, which is the claim the decision rests on; work
leaving the queue once settled, so no second machine repeats it; work submitted with no
machine holding the role waiting instead of failing, and being done when one arrives;
and work a machine handed back coming round again.

One thing I got wrong twice now and have written down where it bit: binding to a
consumer must name that consumer's own filter subject, not the narrower subject the
caller cares about. The client compares the two and refuses anything that is not equal,
with "subject does not match consumer".

internal/link/build.go

@@ -82,6 +82,16 @@ type BuildResult struct {
 	// about the source.
 	On string `json:"on"`
 
+	// Module is what was built, read out of the manifest — the only place it is authoritative, since
+	// a request names a repository and a path.
+	//
+	// **Here because one message now reaches three audiences** (novox/hq ADR 0121). On the bus the
+	// mesh runs on today the answer and the announcement were two publishes to two topologies, so a
+	// result needed no module name and the announcement carried one. On the bus being built the
+	// outcome is the role's own event, and the catalogue reading it needs to know what was built.
+	// Empty on a failed build, which produced no module version.
+	Module string `json:"module,omitempty"`
+
 	// Commit is what was actually built. The mesh records it, which is what makes "is this
 	// current?" answerable without building again.
 	Commit string `json:"commit,omitempty"`