When the receiver type is fully known, `select_trait_methods` now prunes
candidates whose impl is provably inapplicable — self-type mismatch
(`Rejected`) or unsatisfiable `where`-clause (`Unsatisfied`) — before the
single-candidate, visibility, and ambiguity decisions.

Previously a blanket `impl<T: Marker> Trait for T` that cannot apply to the
receiver still counted as a competing candidate, which could turn an
otherwise-unambiguous `concrete.method()` call into a spurious "import the
trait" error: the single-candidate path resolves without the trait being in
scope, but a second, inapplicable candidate defeats it.

Inference-variable receivers keep every candidate, since inapplicability
can't be proven yet. If pruning would remove every candidate, the originals
are kept so the unsatisfied-bound diagnostics still fire.

Replace the per-type Encode/AbiSize/AbiSpan/TopicValue impls for the
custom-width Solidity int wrappers with marker-gated blanket impls over the
sealed `SolInt` marker (renamed from `SolWrappingIntMarker`, now general
purpose), removing ~970 lines of boilerplate.

These blanket impls of foreign traits are admissible via the sealed-marker
mechanism, and resolve cleanly on unrelated types now that inapplicable
candidates are pruned during method selection.

Update the unsupported-field-type diagnostics, which now name the unsatisfied
`SolInt` bound, and add a runtime ABI round-trip fixture covering
Encode/Decode/AbiSize/AbiSpan/TopicValue for these wrappers.

The "trait bound `X: Y` is not satisfied" sub-diagnostic only helps when
the reader can name trait `Y`. For a bound on a trait that isn't visible
from the error location -- e.g. a private sealed marker like `SolInt`
behind a blanket impl in another module -- the hint is unactionable
noise, so suppress it and keep just the primary "`X` doesn't implement
`<public trait>`" line.

Visibility is judged from the scope the error span originates from, via a
new `DynLazySpan::scope` that maps a span's chain root to its HIR scope.
So `pub` and same-scope subgoal traits keep their hint -- including when
the error occurs inside the subgoal trait's own private module -- while a
bound on a trait private to another module is dropped.

`check_impl_cand` solved each of an impl's `where`-clauses but discarded
the solution. When a bound fixes an impl parameter that the self type does
not determine (e.g. `impl<T, U: Marker> Consume<U> for T`), `U` was left as
an unconstrained inference variable and the `U: Marker` obligation was
dropped -- so `x.consume(non_marker)` type-checked and failed only later at
codegen.

Extract the unique solution and unify it back into the table (as the
assumption path in `check_inst` already does) so the trait instance built
for the candidate reflects the bound's bindings. Adds a regression fixture.

The tree-sitter CLI compiles grammar.js into parser.c (96k lines),
grammar.json, node-types.json, and src/tree_sitter/ headers. Tracking
these in git meant a small grammar change produced 40k+ line diffs.

Untrack them and regenerate from grammar.js at build time instead:

- build.rs prefers the pinned CLI in node_modules/.bin, falls back to a
  tree-sitter on PATH, and now fails loudly if neither can produce
  parser.c (rather than letting cc choke on a missing file).
- CI installs the pinned CLI (npm ci --ignore-scripts + npm rebuild
  tree-sitter-cli) and generates the parser before building the jobs
  that compile the grammar (lint, test).
- Add `make test`, which generates with the pinned CLI then runs the
  workspace suite, including the grammar parse test.

The hand-written src/scanner.c stays tracked. The grammar is still fully
exercised by crates/parser/tests/tree_sitter_parse.rs against a freshly
generated parser.

Untrack generated treesitter files

fix: don't lower library modules into duplicate ingot main objects

…otorg#1498)

* Disallow turbofish and instead emit an error
* Consume leading trivias for better diagnostics
* Use current parser position properly

Replace sol-compat int trait impl boilerplate with blanket impls