Added CODE_CONVENTIONS.md and linters to enforce it, and applied it across the codebase

CODE_CONVENTIONS.md sets out the conventions for Go code in this
repository: naming, layout, comments, errors, logging, configuration and
tests. .golangci.json enables the linters that check the parts that can be
checked (each limited to the rules the conventions use); the rest is
applied by hand.

Applied across the codebase:
- Naming: full-word names in application code, initialisms in one case
  (BuyerID, PrintJSON, PrintYAML, ocdsGetBuyerID), no names shadowing
  built-ins (min/max are minGap/maxGap), mustRaw renamed rawJSON as it
  returns nil rather than panicking, and config.ConfigLevelToLogLevel
  renamed LevelToLogLevel.
- Layout: lines kept to 80 characters where possible, assignments taken
  out of if and for statements that don't fit, wrapped arguments all on
  one line or one per line, steps separated by blank lines, no else after
  a return, function and struct literals wrapped.
- Comments: doc comments on every exported name (including each section's
  Map, Flatten, TypeOf, ValueOf and SetValue), section banners, British
  spelling.
- Errors: a created error starts with its package name, a wrapping error
  adds only what was being done, sentinels in one commented var block,
  errors.Is and errors.As in place of == and type assertions, and no
  err := shadowing of a named result. That fixes the mock server losing
  its access log's close error.
- Logging: the fetcher passes its workers an untagged logger, so
  findatender's lines are tagged with their own component rather than
  with fetcher's as well; cmd/mock-fts logs "stopped" with slog.
- Configuration: util.WithTimeout (moved from the websocket package)
  applies a timeout of 0 or less as no limit, used for the websocket
  write and ping, TCP close and tcpserver shutdown timeouts; every setting
  documents what 0 or empty means, including the rate limit rule's keys
  in internal/config/README.md.
- Tests: related tests merged into table-driven ones with named cases.

Separately from CODE_CONVENTIONS.md, internal/store/README.md gains a soft
SQL style convention for the queries in internal/store/queries.go, and the
queries are reformatted to follow it.

internal/util/worker.go

@@ -11,18 +11,18 @@ import (
 // DefaultWorkerShutdownTimeout is used when Worker.ShutdownTimeout is zero.
 const DefaultWorkerShutdownTimeout = 10 * time.Second
 
-// ErrWorkerNoWork tells the Worker that a run succeeded but found nothing to do.
-// Tasks return it, or an error wrapping it, to have the run treated as a
+// ErrWorkerNoWork tells the Worker that a run succeeded but found nothing to
+// do. Tasks return it, or an error wrapping it, to have the run treated as a
 // success (checkpoint advances) while being logged distinctly. For example:
 //
 //	var ErrNoNewReleases = fmt.Errorf("%w: no new releases", ErrWorkerNoWork)
-var ErrWorkerNoWork = errors.New("no work")
+var ErrWorkerNoWork = errors.New("util: no work")
 
 // Task processes everything that has changed since the given checkpoint.
 //
-// Returning nil or an error matching ErrNoWork advances the checkpoint to the
-// time this run started. Any other error leaves the checkpoint unchanged, so
-// the next run retries from the same point.
+// Returning nil or an error matching ErrWorkerNoWork advances the checkpoint to
+// the time this run started. Any other error leaves the checkpoint unchanged,
+// so the next run retries from the same point.
 type Task func(ctx context.Context, since time.Time) error
 
 // Worker runs a Task periodically until its context is cancelled.
@@ -32,7 +32,8 @@ type Worker struct {
 	// Interval is how often Task runs. Must be greater than zero.
 	Interval time.Duration
 	// ShutdownTimeout is how long an in-flight Task may keep running after
-	// the parent context is cancelled. Zero means DefaultShutdownTimeout.
+	// the parent context is cancelled. 0 or less means
+	// DefaultWorkerShutdownTimeout.
 	ShutdownTimeout time.Duration
 	// Task is the work to perform on each tick.
 	Task Task
@@ -45,14 +46,16 @@ type Worker struct {
 // cancelled. It blocks until shutdown has finished.
 func (w Worker) Run(ctx context.Context, since time.Time) error {
 	if w.Task == nil {
-		return fmt.Errorf("worker %q: no task configured", w.Name)
+		return fmt.Errorf("util: worker %q: no task configured", w.Name)
 	}
 	if w.Interval <= 0 {
 		return fmt.Errorf(
-			"worker %q: interval must be greater than 0, got %s",
-			w.Name, w.Interval,
+			"util: worker %q: interval must be greater than 0, got %s",
+			w.Name,
+			w.Interval,
 		)
 	}
+
 	timeout := w.ShutdownTimeout
 	if timeout <= 0 {
 		timeout = DefaultWorkerShutdownTimeout
@@ -124,7 +127,11 @@ func (w Worker) execute(
 		logger.Info("task completed", "elapsed", elapsed)
 		return start
 	case errors.Is(err, ErrWorkerNoWork):
-		logger.Info("task completed with nothing to do", "reason", err, "elapsed", elapsed)
+		logger.Info(
+			"task completed with nothing to do",
+			"reason", err,
+			"elapsed", elapsed,
+		)
 		return start
 	case errors.Is(err, context.Canceled):
 		logger.Warn("task cancelled", "elapsed", elapsed)
@@ -142,22 +149,22 @@ func (w Worker) execute(
 // The result channel is buffered, so if ctx wins the race the goroutine can
 // still deliver its result and exit instead of blocking forever.
 func AwaitTask[T any](ctx context.Context, task func() (T, error)) (T, error) {
-	type result struct {
-		val T
-		err error
+	type outcome struct {
+		value T
+		err   error
 	}
-	results := make(chan result, 1)
+	results := make(chan outcome, 1)
 	go func() {
 		value, err := task()
-		results <- result{
-			val: value,
-			err: err,
+		results <- outcome{
+			value: value,
+			err:   err,
 		}
 	}()
 
 	select {
 	case result := <-results:
-		return result.val, result.err
+		return result.value, result.err
 	case <-ctx.Done():
 		var zero T
 		return zero, ctx.Err()