Judge how a module says it is ready, beside whether it stays up (hq ADR 0240, to-be 48 Phase B)

Liveness alone could not see a web application whose port was open and whose
program ran while every request hung for eleven hours (issue 145). A resource
now carries the `health` its module declared: the engine makes http and tcp
looks itself from the machine to the endpoint's published port, reads a unit's
readiness from the show it already makes, hands an exec command or the image's
own check to the runtime as the container's check with the declared timing and
reads its state from the inspect it already makes, and asks a module's tool on
its own node tools. Starting until the check passed, unhealthy once its looks
after the grace fail the declared number of times; never more looks than the
measured budget; nothing restarted. The statement says contract 2, which tells
the controller this engine may be sent the field.

internal/link/queue.go

@@ -5,6 +5,7 @@ import (
 	"crypto/sha256"
 	"encoding/hex"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"sync"
 	"time"
@@ -511,3 +512,45 @@ func (q *Queue) timeout() time.Duration {
 	}
 	return q.Timeout
 }
+
+// AskTool asks a module's tool on this machine's own node tools, as a declared health check (novox/hq ADR
+// 0240, to-be 48 §3), and reads its answer: healthy or not, with why. An error when there is no link open
+// or nothing answered — said as the check's failure, never as healthy.
+func (q *Queue) AskTool(ctx context.Context, module, tool string) (bool, string, error) {
+	q.init()
+	q.mu.Lock()
+	bus := q.bus
+	q.mu.Unlock()
+	asker, ok := bus.(ToolBus)
+	if bus == nil || !ok {
+		return false, "", errors.New("no link to the bus is open")
+	}
+	reply, err := asker.Ask(ctx, ToolSubject(module, tool, q.Membership.Node), []byte("{}"))
+	if err != nil {
+		return false, "", err
+	}
+	return ReadToolAnswer(reply)
+}
+
+// ReadToolAnswer reads a tool's reply envelope — `{result, error}`, as the node tools answer every call —
+// as a health answer: an error is not healthy, and so is a result that does not say `healthy: true`.
+func ReadToolAnswer(reply []byte) (bool, string, error) {
+	var env struct {
+		Result json.RawMessage `json:"result"`
+		Error  string          `json:"error"`
+	}
+	if err := json.Unmarshal(reply, &env); err != nil {
+		return false, "", fmt.Errorf("its answer is not one: %w", err)
+	}
+	if env.Error != "" {
+		return false, env.Error, nil
+	}
+	var a struct {
+		Healthy bool   `json:"healthy"`
+		Why     string `json:"why"`
+	}
+	if err := json.Unmarshal(env.Result, &a); err != nil {
+		return false, "it answered something other than healthy or not", nil
+	}
+	return a.Healthy, a.Why, nil
+}