Keep what each machine did, so status can say what is wrong

A node reports back after applying a declaration: it worked, some of it
failed, or the whole thing was refused. A refusal or a failure moved
last_seen and the reason went to a log line — so "which machine is not
doing what it was told" had no answer the next morning, which is the
question a mesh exists to answer.

Refused and failed are kept as different things, because they are
different situations with different remedies: refused means the machine
is exactly as it was and what is wrong is in what was sent; failed means
it is in a state nobody declared and what is wrong is on the machine. One
word for both would make the record say less than the node did.

One row per node, replaced. The question is the machine's current state —
"this failed an hour ago and then succeeded" is not a machine anybody
needs to look at, and a table of every report would bury the ones that
matter under the ones that do not.

`status` now answers three questions in the order somebody asks them: is
anything broken, is anything not answering, is anything out of date. The
first has consequences now, the third is a plan for later, and a status
leading with the third would bury the first. A machine that has never
spoken is reported as quiet rather than as broken — new, switched off and
unreachable are not the same as tried and could not.

The mapping from a report to an outcome had no test at all, which the
injection caught: it is the code deciding which of those situations a
machine is in. It has four now, including that a partial report never
becomes the account of what the machine holds — the fault that destroyed
a substrate once.

internal/link/enrolment.go

@@ -7,6 +7,7 @@ import (
 	"encoding/base64"
 	"errors"
 	"fmt"
+	"sort"
 
 	"github.com/novox/mesh-control/internal/broker"
 	"github.com/novox/mesh-control/internal/identity"
@@ -141,6 +142,29 @@ func (e Enrolment) Heard(ctx context.Context, report Report) error {
 	if err != nil {
 		return err
 	}
+	// What it did is kept whichever way it went. Until this, a refusal or a failure moved
+	// last_seen and the reason went to a log line, so "which machine is not doing what it was
+	// told" had no answer the next morning — which is the question a mesh exists to answer.
+	doing := inventory.Doing{
+		Outcome: inventory.OutcomeApplied,
+		Refused: report.Refused,
+		Applied: len(report.Applied),
+	}
+	switch {
+	case report.Refused != "":
+		doing.Outcome = inventory.OutcomeRefused
+	case len(report.Failed) > 0:
+		doing.Outcome = inventory.OutcomeFailed
+	}
+	for id, why := range report.Failed {
+		doing.Failed = append(doing.Failed, inventory.FailedResource{ID: id, Error: why})
+	}
+	// 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 })
+	if err := e.Inventory.RecordDoing(ctx, node.ID, doing); err != nil {
+		return err
+	}
+
 	// A refusal, a failure, or a bare word that the node is there — none of them is an account of
 	// what the machine holds, so each moves last_seen and nothing else. Recording a partial list
 	// as though it were the whole would tell a rebuilding node to remove what it still has.