Assign around what a machine already holds

The other half of ADR 0038, and what 04-ISSUES/028 was actually about.
A module can now avoid colliding with another module; until this it
could not avoid colliding with the mesh itself.

The substrate is not a module. A node raises it from the bundle it
carries before any mesh exists, so the control plane had never heard of
the store, the broker, or its own container — and handed a database
module 5432, which the store already had.

So the machine says. The host records what each resource binds,
distinguishing what it carried from what the mesh sent — a distinction
that already existed so the two never remove each other — and reports
the carried ones. The node states and this context writes, which is the
shape of every message between them.

What the declaration binds, not what is open. A machine's open ports are
a moving target, and assigning around them would mean a port that was
free when it was asked for and taken when it was used.

Replaced whole each time rather than merged: a machine that gave a port
back must be believed about that too, and a set that only grows keeps a
port reserved for something no longer there.

Tested against a real database, and the tests bite — removing the check
hands the module 20000, which the machine had said it holds.

internal/link/enrolment.go

@@ -170,6 +170,13 @@ func (e Enrolment) Heard(ctx context.Context, report Report) error {
 	}
 	// Ordered, so two readings of one failure are the same reading.
 	sort.Slice(doing.Failed, func(i, j int) bool { return doing.Failed[i].ID < doing.Failed[j].ID })
+
+	// And what that machine says it already holds, so a port is assigned around it rather than
+	// on top of it (novox/hq ADR 0038). Kept even when the declaration was refused: what the
+	// machine carries is true regardless of what it thought of the last thing it was sent.
+	if err := e.Inventory.RecordCarried(ctx, report.Node, report.Carried); err != nil {
+		return err
+	}
 	if err := e.Inventory.RecordDoing(ctx, node.ID, doing); err != nil {
 		return err
 	}

internal/link/protocol.go

@@ -85,6 +85,15 @@ type Report struct {
 	Applied []string          `json:"applied,omitempty"`
 	Failed  map[string]string `json:"failed,omitempty"`
 	Refused string            `json:"refused,omitempty"`
+
+	// Carried are the machine's ports held by what that host raised from its own bundle.
+	//
+	// **The half the mesh cannot know** (novox/hq ADR 0038). The substrate is not a module — a
+	// node raises it before any mesh exists — so without being told, the mesh assigns a module a
+	// port the store or the broker already holds, and hears about it from a container runtime.
+	//
+	// The node states and this context writes, which is the shape of every message here.
+	Carried []int `json:"carried,omitempty"`
 }
 
 // EnrolReply is what the mesh says back.