Cardano Updates

- Elab.hs: fix copy-paste error in binary arithmetic op elab (rhs hole was
  unified against lhsTy instead of rhsTy); rename evalBinaryArithmethicOpElabProblem
  to evalBinaryArithmeticOpElabProblem (typo)
- Elab.hs: elaborate `metrics` as List Text (was Text); add Str elab case
- Elab/Typing.hs, Resolve.hs, Unify.hs: add List Ty to support metrics type
- Interp.hs: guard avg/min/max against empty instant vector; fix rate to
  error on single-point timeseries instead of dividing by zero
- Interp/Value.hs: use showFFloat in Show instance for Scalar to avoid
  scientific notation in JSON output
- TimeseriesServer.hs: fix minimumRetentionMillis units (seconds → ms);
  remove unused RecordWildCards pragma; align sleep delay with Monitoring.hs
- Acceptors/Utils.hs: align new imports with surrounding import block

New routes on the timeseries server:
  GET /timeseries/nodes                        — list connected node IDs
  GET /timeseries/node/{id}/info               — NodeInfo + uptimeSeconds
  GET /timeseries/node/{id}/startup            — NodeStartupInfo
  GET /timeseries/node/{id}/state  (RTVIEW)    — sync progress %

The server now receives TracerEnv instead of individual fields so it can
access teDPRequestors, teCurrentDPLock, and teConnectedNodes.

The /state endpoint uses data point key "NodeAddBlock" (the namespace
cardano-node actually stores the NodeState data point under) rather than
"NodeState", which was always empty.

New query types in the datasource plugin:
  nodes       — lists all connected node IDs (used by $node_id variable)
  node-info   — name, protocol, version, commit, start time, uptime
  node-startup — era, slot length, epoch length, KES period
  node-state  — sync progress %

New panels in rtview.json (all repeat by $node_id variable):
  Connected Nodes table, Node Info table, Startup table,
  Sync % stat, Uptime stat

metricFindQuery populates the $node_id query variable automatically
from /timeseries/nodes.

$__from/$__to in timeseries queries are pre-processed to valid
timestamp expressions before template variable expansion.

Replace GNU ps long-option syntax with pgrep -P, which is available
on both macOS (BSD) and Linux.

Add 6-dense-timeseries-1h as a copy of 6-dense-1h with tracerTimeseries
enabled: 6 nodes, 1-hour duration, dense topology. The tracerTimeseries
combinator in Primitives.hs is retained. Regenerate all-profiles-coay.json.
Enable RTView in this profile.

Replace hardcoded [now - 1h; now] in all 25 dashboard panels with
[$__from; $__to] so the Grafana time picker controls the window.

Pre-process $__from/$__to in the datasource plugin before getTemplateSrv()
sees them — Grafana treats these as built-in variables and ignores
scopedVars overrides — converting them to epoch + Nms expressions that
the query language interprets as absolute timestamps.

When a variable is not found in either the local context or the metric
store, the elaborator now appends a "Did you mean: ..." hint by ranking
all candidate names (locals + metrics) by Levenshtein distance and
showing the closest ones (up to 5) within threshold max(1, len/3).

Uses the `edit-distance` library (the canonical Haskell implementation,
also used by GHC for its own "did you mean" diagnostics).

All three rules fire only when the known type information uniquely
determines the outcome:

  ? - Duration : ?  ->  Timestamp - Duration : Timestamp
    Only Timestamp - Duration exists with Duration on the Sub rhs.
    Enables: \x -> x - 1s  (infer x : Timestamp)

  ? + ? : Duration  ->  Duration + Duration : Duration
    Only Duration + Duration produces Duration.
    Enables: \x -> \y -> m [now; now : x + y]  (infer both : Duration)

  ? - ? : Timestamp  ->  Timestamp - Duration : Timestamp
    Only Timestamp - Duration produces Timestamp via Sub.
    Enables: \x -> \y -> m [x - y; x]  (infer x : Timestamp, y : Duration)

Ordering: A (? - Duration) before C (? - ? : Timestamp) so the more
specific rhsTy=Duration match takes priority. B (? + ? : Duration)
after the existing Duration + Duration : ? rule so the known-both-sides
case is tried first.

When both operands are known to be Duration but the result type is
still a hole, force the hole to Duration and re-queue as the canonical
Duration + Duration : Duration problem. This allows standalone
expressions like `1s + 2s` to elaborate without needing an outer
context to drive the result type.

- JSON.hs: rename tag/value to resultType/result; use Prometheus
  resultType names (scalar, vector, matrix); encode timestamps and
  durations as Unix seconds (Double); encode data-point values as
  strings; rename labels->metric and data->values in Instant/Timeseries
- TimeseriesServer: parse query endpoint body as
  application/x-www-form-urlencoded (Prometheus wire format); add GET
  support alongside POST, sharing a single handleQuery helper
- grafana-datasource: update types, toDataFrames, and datasource to
  match new wire format; switch fetch to x-www-form-urlencoded

Replaces the 7-test skeleton with a comprehensive suite covering all
elaborator code paths: literals, duration literals, arithmetic
(well-typed and ill-typed), comparisons, boolean operators, let/lambda,
pairs/projections, to_scalar, abs/round, metrics builtin, range
vectors, instant-vector operations, and metric-name resolution (known
metric, undefined name, Levenshtein suggestions).

Notes two elaborator bidirectionality constraints discovered via
test failures:
- `Duration + Duration` requires the result type to be driven by
  a containing expression (tested via `now + (1s + 2s)`).
- `\x -> x + 1` leaves `x`'s type unconstrained; replaced with
  `\x -> now + x` which forces `x : Duration` via the Timestamp+?
  noncanonical rule.

- Parse/eval errors from the server are now surfaced as DataQueryError:
  the banner shows the first line (summary); the full multi-line message
  (source location + caret) is in data.message for the inspector
- Requests go via Grafana's server-side proxy (instanceSettings.url) to
  avoid CORS and host-resolution issues in the browser
- Add Unit value: renders as an empty frame (no data to display)

**cardano-tracer / cardano-timeseries-io**
- Add `Cardano.Timeseries.JSON` with `ToJSON` instances for `Value`, `Instant`,
  `Timeseries` and `SeriesIdentifier` (orphan module, imported for side-effects)
- Switch `POST /timeseries/query` response from plain text to `application/json`

**cardano-profile**
- Add `timeseries :: Bool` field to `Tracer`
- Add `tracerTimeseries` primitive
- Add `ci-bench-timeseries` profile: 2-node local cluster with timeseries endpoint
  enabled, no shutdown condition, generator runs for 100 000 epochs (effectively
  indefinite) — intended for interactive exploration via Grafana
- Regenerate `all-profiles-coay.json` and `wb_profiles.mk`; update all test fixtures

**Nix**
- `cardano-tracer-service-workbench.nix`: add `timeseries` option → `hasTimeseries`
- `cardano-tracer-service.nix`: add `timeseriesEnable/Host/Port` NixOS options
- `tracer.nix`: wire `profile.tracer.timeseries` → `{epHost, epPort = 3400}`
- `supervisor.sh`: replace hanging `netstat -pltn` with `lsof -nP -iTCP:9001
  -sTCP:LISTEN` for macOS compatibility

**bench/grafana-datasource** (new)
- TypeScript Grafana datasource plugin (`iog-cardanotimeseries-datasource`)
- Sends `POST /timeseries/query` via Grafana server-side proxy (avoids CORS)
- Converts `Value` tagged-union JSON to Grafana `DataFrame[]`
- `docker-compose.yaml` for local development; datasource auto-provisioned at
  `http://host.docker.internal:3400`; Colima-compatible (`extra_hosts`)

St now carries availableMetrics :: Set MetricIdentifier, populated at
the call site via metrics store (or Set.empty in metric-free contexts
like the elab test suite).

The fallback Variable case — previously an unconditional metric assumption
— now checks membership in availableMetrics and throws "Undefined name: <v>"
when the name appears neither in the local context nor in the store,
replacing the confusing downstream type-mismatch error that occurred before.

Drop the checkFresh guard so duplicate names are no longer rejected.
Change variable lookup to search the context right-to-left (Seq.reverse)
so that the innermost binding wins, as scoping requires.

- Add provisioned Grafana dashboard mimicking RTView's four sections:
  Resources, Blockchain, Leadership, Transactions (26 panels, row-based
  collapsible sections, byte units for memory/mempool panels)
- Pin datasource uid in provisioning so dashboard references are stable
- Mount dashboards directory in docker-compose
- Enable RTView (hasRTView, port 3300) in ci-bench-timeseries profile
  alongside the existing timeseries endpoint

The test suite covers scalar/bool arithmetic and comparisons, duration and
timestamp literals, type conversions (to_scalar, abs, round), pairs, let/lambda,
InstantVector lookup/aggregation/filter/map/label-filter/unless/join,
InstantVector-Scalar arithmetic and relations, RangeVector aggregations
(avg_over_time, sum_over_time, rate, increase, quantile_over_time), and
metrics.

Writing the tests surfaced a bug in Elab.hs where Surface.SumOverTime was
elaborated to Semantic.AvgOverTime instead of Semantic.SumOverTime, causing
sum_over_time queries to silently return the mean.  Fixed.

The `epoch` keyword was mapped to `Now` in the parser, making it
identical to `now` (i.e. current server time).  It now produces
`Epoch`, which the interpreter evaluates to `Timestamp 0` (Unix
epoch), so expressions like `epoch + 1778499300385ms` yield the
intended absolute timestamp rather than ~year 2082.

Introduces Nil and Cons constructors to both the expression language and
the value domain. The primary motivation is to give the built-in Metrics
expression a well-typed return value: it now returns a proper linked list
of Text values (metric names) rather than a right-nested Pair tuple
terminated by Unit, making it possible to assign it the type List Text in
the elaborator.

- Interp: Metrics now builds a Nil/Cons spine instead of a Pair/Unit tuple
- JSON: ToJSON instances for Nil and Cons (tag/head/tail encoding)
- Show: show Nil = "[]", show (Cons h t) = "[h|t]"
- Resolve: structural pass-throughs for Nil and Cons
- Grafana plugin: Nil/Cons variants in the TypeScript Value union;
  Cons case walks the spine into a string table frame, Text items
  render their actual string value