feat(runtime): evaluate the unbounded value * and elem.metadata

[devin-ai-integration]

What and why

Two value forms the runtime could not produce are now evaluated.

* as a value. Expression-position * was parsed but not evaluable, so a body stating it
was reported as an unevaluable expression. It now evaluates to a dedicated unbounded scalar,
semantics.Value{Kind: ValInfinity}, carried as a ValConst runtime value. It is a semantic
kind of its own rather than an IEEE infinity, so it can never be mistaken for a number:

• ordering: greater than every finite Integer, Real and Natural, equal to itself, so <, <=,
  > and >= all answer consistently (semantics.UnboundedOrder / OrderSatisfies);
• printing: * everywhere — value formatting, trace formatting, the REPL's document queries and
  the solver's pinned values, which previously spelled it ∞, a spelling no SysML source uses;
• arithmetic: refused before any numeric conversion with a typed ErrTypeMismatch naming the
  operation, for +, -, *, /, %, ** and both unary forms, e.g.
  type mismatch: operator '+' is not defined for the unbounded value '*': * + 1. No panic, no
  NaN, no silently narrowed finite answer;
• the wire: its own Value oneof arm (bool infinity = 16) rather than the string "*", which
  stays an ordinary string. The arm is advertised as the infinity_value capability and behaves
  like the other value-arm capabilities — withheld as an unsupported null in a response, and
  refused with UNIMPLEMENTED in an input — with the Go, Java, Python, Node and Rust clients
  and the wire contract updated for it.

The checker types the literal as ScalarValues::Positive, which the standard library declares as
the natural number exceeding every other, so conformance of attribute n : Natural = *; follows
from the library rather than from a runtime special case.

elem.metadata. ref.metadata now parses as a metadata access rather than a feature chain
through a member named metadata, and evaluates from the annotation side table the @@
classification already reads — no re-derivation and no reparsing of declarations. The semantic
layer materializes that table into semantics.ElementMetadata (type, node, scope, and the
features bound in the annotation body, in declaration order); the runtime turns each entry into
a metadata instance through the existing instance materialization, so a feature the body binds
answers that value and one it does not answers the metadata type's default. An element with no
metadata answers the empty sequence. A non-element operand (1.metadata) is an
ErrTypeMismatch, an unresolved name an ErrUnresolvedReference, and a body binding naming a
feature the metadata type does not have an ErrTypeMismatch naming both — never a dropped
value.

Specification basis

• * in expression position: KerML 8.4.4.6 (unbounded natural), typed through
  ScalarValues::Positive as the library declares it.
• Metadata access: KerML 8.4.4.10 (metadata access expressions), whose result is the metadata
  features of the referenced element.

Both add rows to the Expression Evaluation table in docs/project/spec-compliance.md (✅), and
the new wire arm is documented in docs/reference/wire-contract.md and
docs/reference/service-transports.md.

How it was verified

New coverage:

• conformance: value_unbounded_comparison, value_unbounded_arithmetic_refused (every refused
  operation) and metadata_access_annotations (bound body values, defaults, about metadata,
  several annotations in order, and an element with none), plus an Infinity expected-value type
  in the conformance schema and its README;
• golden AST: internal/core/parser/testdata/parse/unbounded_and_metadata_access.sysml;
• robustness: arithmetic over *, * compared with a string, .metadata on a value, and
  .metadata on an unresolved name — each a typed error;
• unit: internal/core/runtime/infinity_test.go, metadata_test.go and
  internal/grpc/convert_infinity_test.go (round trip of the arm, of * nested in a sequence,
  the withheld null and the refused input without the capability, and "*" still an ordinary
  string).

One existing test changed intentionally. TestUnevaluableResultIsNotReportedAsMissing used
Foo.metadata and * as its two expressions the evaluator has no value kind for; both are now
evaluable, so the model states ~n and n as Foo instead — two forms
unimplementedOperators still declares unevaluated. The test's contract (an unevaluable result
is reported as such, not as a missing result) is unchanged. internal/repl/runtime_commands_test.go
moved from ∞ to * with the formatter.

A follow-up commit fixes a difference the prompt showed against the same document over gRPC:
the about index keys the annotated element by symbol, while the prompt evaluates against a
scope tree re-indexed from the same declarations, so its twin of the element reached none of the
annotations stated about it — elem.metadata and a package's metadata read as empty at the
prompt while gRPC answered them. The index now keys those annotations by the annotated element's
declaration as well, which identifies it across both trees
(internal/repl/metadata_about_eval_test.go).

$ gofmt -l .            # empty
$ go build ./...        # ok
$ go vet ./...          # ok
$ go test ./...         # ok
$ python3 scripts/changelog.py check   # ok
$ OPENSYSML_REQUIRE_TRAINING_CORPUS=1 OPENSYSML_REQUIRE_PILOT_CORPORA=1 \
    go test -count=1 ./internal/core/model -run 'TestTrainingExamples|TestPilotCorpora'
ok      github.com/Open-MBEE/OpenSysML/internal/core/model      16.315s

Known limitation: * is a value and an ordering bound only — no arithmetic over it is defined,
by design, since KerML gives none.

Checklist

• make test and make lint pass locally
• Tests added or updated for the change
• Documentation extended where it already covers the surface (see CONTRIBUTING.md)
• Changelog entry added as changes/unreleased/<slug>.<section>.md, not as an edit to CHANGELOG.md
• baselines regenerated and make docs-counts run if a gate count moved (compliance rows need nothing: the census is counted at docs build)
• No internal work-item labels (waves, slices, F4, K5) in the body, docs, or changelog

[devin-ai-integration]

🤖 Devin AI Engineer

I'll be helping with this pull request! Here's what you should know:

✅ I will automatically:

• Address comments on this PR. Add '(aside)' to your comment to have me ignore it.
• Look at CI failures and help fix them

Note: I can only respond to comments from users who have write access to this repository.

⚙️ Control Options:

• Disable automatic comment, CI, and merge conflict monitoring

[devin-ai-integration]

Runtime-verified by hand through the REPL and through the gRPC service with the Python client, beside the suite.

Verified: * prints as * and never as ∞, Inf or NaN; the comparisons against Integer, Real and Natural, in sequences and through both conditional branches; every binary operator with the unbounded value on either side and both unary forms refused with a type mismatch naming the operation, the prompt still evaluating 1 + 1 afterwards; the value spelled * in a document query's upper multiplicity, in a calculation trace and in a solver pin diagnostic, which refuses an infinite magnitude rather than solving it; inline metadata order, bound values, type defaults, the empty sequence of an unannotated element and the typed non-element and unresolved-name errors; the Value.infinity arm distinct from the ordinary string "*", retained inside sequences, advertised as infinity_value by GetServerInfo, and round-tripped through an action.

That pass found the prompt answering elem.metadata without the annotations stated about the element while the same document answered them over gRPC — a symbol-identity difference in the about index, fixed in the follow-up commit and locked by internal/repl/metadata_about_eval_test.go.

Not exercised by hand: the Java, Node and Rust clients, and the capability-withholding path (both covered by tests only). Ordering note: mixed inline and about annotations answer inline-first, which is the order the annotation side table an element filter classifies by already used, and which the compliance row states.