agent: Improve LSP tool symbol resolution and definition lookup

[AJenbo]

This PR improves the SymbolLocator::resolve() used by all LSP tools (go_to_definition, find_references, rename_symbol, get_code_actions) to be more robust when agents provide slightly inaccurate positions, and improves go_to_definition to prefer type definitions.

Symbol resolution improvements

The existing implementation does a plain substring match on the exact line specified. This fails in several common cases:

1. False substring matches — Searching for Payment on a line containing captureReservedPayment(Payment $payment) would match inside captureReservedPayment first, positioning the cursor in the middle of the wrong symbol.

Fixed with word boundary matching: Only standalone occurrences are matched. Word characters are alphanumeric and _. Special prefixes ($, @, #) skip the left-boundary check since they already act as delimiters.

2. Off-by-one line numbers — Agents frequently land on the blank line before code (e.g. the line before a function signature) because selection ranges and outline results sometimes point there.

Fixed with nearby line search (±4 lines): If the symbol isn't found on the exact line, nearby lines are searched before giving up.

3. Wrong casing — Agents sometimes use PaymentToken when the code has paymentToken, especially when paraphrasing from memory.

Fixed with case-insensitive fallback: Case-sensitive matching is tried first and preferred; case-insensitive is used only when no exact match exists.

Definition lookup improvement

go_to_definition now tries type_definitions first, falling back to regular definitions. This means navigating to a variable like $order takes you to the Order class rather than the assignment site, which is usually more useful when exploring code.

Testing

Unit tests cover word boundary matching, case-insensitive fallback, special prefix handling, and no-match cases.

Release Notes:

• Improved LSP agent tools to be more robust when the agent provides slightly inaccurate symbol positions (word boundary matching, nearby line search, case-insensitive fallback).

[cameron1024]

I'm not sure this is a good default behaviour. Getting type defintions can be useful, definitely, but so can finding the declaration of a variable (or struct/class/etc. field). I don't think one is necessarily more useful than the other.

I think there's scope for an extra tool, or perhaps merging the "goto X" tools into a single tool with a field that allows the agent to specify whether it wants to see the declaration, type definition, references, implementations, etc. For now though, we're just evaluating a limited subset.

[AJenbo]

It now just calls project.definitions() directly instead of trying type_definitions first. Removed the doc comment paragraph about type definitions.

[cameron1024]

This function is quite complex, and encodes some language-specific details that I'm not sure we can rely on in all cases. For example, the string foo$ can be a full identifier (e.g. in Dart, where $ is a non-special symbol when used in identifiers), or it could be an identifier and operator (e.g. in Lean4, where $ is function application). Or a-b is an identifier in Nix, but in C-style langauges it's a minus b.

The ideal solution would be using the syntax tree, but that's a relatively complex change.

The point you make about void handlePayment(Payment payment) not being able to resolve the type is a fair point though, and we should handle this better. For this purpose, I actually think ignoring casing is actually not the right approach, since:

• the case can provide useful information (e.g. const FOO: Foo = ...)
• it doesn't actually work in languages that use snake_case or kebab-case heavily

I think a simpler implementation could:

• split the haystack based on some conservative regex for non-identifier characters (whitespace, and symbols excluding $, @, #, -, and maybe some others)
• search the current line for an exact symbol match
• if that fails, try the line before and the line after
• repeat, expanding the context each time, failing after some maximum context size

[AJenbo]

Replaced the complex find_word_bounded/find_word_bounded_impl/find_word_bounded_case_insensitive functions with a single find_symbol_on_line that uses is_identifier_char (alphanumeric, _, $, @, #, -) for token boundary checks. Removed case-insensitive fallback entirely.

[cameron1024]

I'm not sure if we need to strip whitespace - seems like a bit of a footgun if we end up concatenating multiple lines together, we lose indentation information.

But if we are going to do it, this method doesn't need to allocate

[AJenbo]

Ok, it no longer strips leading whitespace. Just truncates to MAX_LINE_DISPLAY_LEN and trims trailing whitespace using &str slicing to reduce allocation.