fix(#6040): report Solidity entity lines from the declaration, not the comment above it

[arthurgeron]

Fixes the three line-attribution causes in #6040 plus the missing import line, one change each.

stripCommentsAndStrings restores newlines after blanking. The blanking pass is byte-for-byte, so a single post-pass over the output covers the block-comment loop, both string-literal loops and their escape branches, and any blanking construct added later. Its doc comment now states the invariant callers rely on: same byte length and same newline positions as the input.

The five declaration regexes anchor ^[ \t]* instead of ^\s*. That is the set of characters that can precede a declaration on its own line. (?m)^ anchors after the \n, so a CRLF \r is always trailing and this is not a CRLF regression. importRE is in that set because the next change gives import entities a line, which makes its anchoring load-bearing for the first time.

Members anchor on lineOf(src, bodyStart-1), the opening brace, instead of the contract's match start. That also covers the case where a member declared on the first body line reported the contract's own line, because the member regex could match at offset 0 of the body.

buildImportEntities uses FindAllStringSubmatchIndex and sets StartLine and EndLine.

• Also collapses the four open-coded strings.Count(src[:off], "\n") + 1 expressions in this file onto a lineOf helper, matching the razor, lisp, vue, bicep and deprecation extractors.
• buildImportEntities and collectImportPaths still run on raw source rather than the scrubbed text, so an import written at a line start inside a block comment produces an entity. It previously carried line 0 and now carries a confident line. Fixing that changes entity counts rather than positions, so it is not in this PR.
• The core_extraction registry note drops a parenthetical that cited a corpus outside this repository. The claim it qualified is unchanged.

TestSolidity_LineAttribution pins both imports, the contract, the event, the modifier and the function against a fixture combining a wrapped contract header, multi-line NatSpec, a doc comment and a block comment. Every subtest fails at 18d466f and passes after.

go test ./... green (229 packages with tests of 242), go vet ./... and gofmt -l internal/extractors/solidity clean, and tools/coverage validate (0 errors), backfill --check and fmt --check exit 0 with gen reproducing the committed docs/coverage exactly. Coverage matrix updated per AGENTS.md.

Closes #6040

[cajasmota]

This is a really good one. Thank you.

The part I want to call out first is the newline restoration. Rather than patching each blanking site — the block-comment loop, both string-literal loops, both escape branches — you did one byte-for-byte post-pass over the output. That covers all five paths and anything added later, which is exactly the property you want in a scrubber that other code derives positions from. And then you wrote the invariant into the doc comment ("same byte length AND the same newline positions as src, so an offset into it names the same byte, and the same line"), so the next person knows what they're allowed to rely on instead of having to infer it. That's the difference between a fix and a fix that stays fixed.

The diagnosis is precise in a way that made the whole thing easy to follow: three causes, each located exactly, and the observation that they compound — a block comment collapsing to one line, then \s walking the match start back over the blanks it left behind, then members measured from the contract's match start so they also absorb a wrapped inheritance list. Each one alone would be a small drift; stacked, the error grows with the height of the comment.

^[ \t]* is the right call, and I appreciated that you worked out the CRLF reasoning rather than leaving it as a worry — (?m)^ anchors after the \n, so a \r is always trailing on the previous line and never leads the match. Anchoring members on lineOf(src, bodyStart-1) is likewise the correct base, and noticing it also fixes the first-body-line case (where a member could match at offset 0 of the body and report the contract's own line) is the kind of thing that's easy to miss.

Two smaller things I liked: collapsing the four open-coded strings.Count(...) + 1 expressions onto lineOf, matching the razor/lisp/vue/bicep extractors rather than inventing a local idiom; and the fixture, which puts a wrapped contract header, multi-line NatSpec, a doc comment and a block comment in one file so all four defect shapes are exercised together instead of in isolation.

And thank you for the scope note about import inside a block comment still producing an entity. You're right that it's a different change — it moves entity counts, not positions — and saying so explicitly is much more useful than either silently fixing it or silently leaving it.

Coverage registry and capability map updated again, correctly, without being asked. That keeps being appreciated.

Merging as-is. Nothing needed from you.