Add F# code snippets (Ctrl+K,Ctrl+X / Ctrl+K,Ctrl+S) - #20521

Insert Snippet (Ctrl+K,Ctrl+X), Surround With (Ctrl+K,Ctrl+S), Tab expansion of a snippet
shortcut, and the keys that drive a live expansion session.

Nothing here reuses Roslyn: its snippet stack is `internal` under
`LanguageServices.Implementation.Snippets` with no ExternalAccess surface, so F# writes its own
`IVsExpansionClient` the way it already writes its own brace completion. The commands come in
through one MEF `ICommandHandler<_>` part, ordered after the completion handler so that Tab
still commits an open completion list first.

Indentation is the F#-specific part. The expansion engine inserts snippet text verbatim, and
C# gets away with that because Roslyn's formatter reflows the result afterwards; F# has no
formatter, so `FormatSpan` computes the columns. That arithmetic lives in `SnippetIndentation`,
free of editor types so that it can be tested on its own - the policy is where the mistakes
live, not the buffer edit that applies it. A directive wrapper is its own line kind:
`#if`/`#else`/`#endif` and the scoped `#nowarn`/`#warnon` pair read at the left margin whatever
they wrap, so the code they cover keeps the column it had.

Two things worth knowing for anyone reading `IVsExpansionClient` next to Roslyn's:
`tsInsertPos` is the range `InsertNamedExpansion` replaces, so handing it the selection deletes
the code a SurroundsWith snippet was meant to wrap; and `GetFieldSpan "selected"` does not
answer for that special literal, so the substituted range is derived from the template's own
`$selected$` line plus the line count the command handler took before the insertion.

`ClassName()` and `GenerateMatchCases()` back the `ctor`, `equals` and `match` snippets. Both
are synchronous COM callbacks, so they block; `ClassName()` blocks on a parse and
`GenerateMatchCases()` on the stale-tolerant check-results path, falling back to a visible
`| _ -> ()` rather than waiting unbounded.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

A RequireQualifiedAccess union rejects a bare case pattern (`A`, not `U.A`) - the
generated pattern binds a fresh variable instead of testing the case, so it takes the
first arm regardless of the actual value. matchRulesFor now qualifies with the
entity's DisplayName when the union carries the attribute, the same way it already
does for enums.

ClassName() used the navigation item's LogicalName, which is qualified by every
enclosing module ("Outer.C") - it does not resolve from a constructor sitting inside
C's own scope. Strips to the name after the last '.'.

GenerateMatchCases() resolved the lexer symbol nearest the field's end position,
which is whatever identifier happens to sit there - for `f x`, that is `x`, not the
call `f x`. Reads the type the checker captured for the field's whole span instead
(TryGetCapturedType), so it matches the expression's own result type regardless of
its shape.

Surround With reindented every non-first selected line uniformly, including a line
that is itself inside a multi-line string continued from an earlier selected line -
inserting indentation there changes the string's value, not just its position.
classifyLines now threads the lexer's color state across the span and classifies
such a line as InsideString, left untouched like a blank line.

lock.snippet closed the lambda on the same line as $selected$$end$, so a selection
whose last line ends in a trailing // comment swallowed the closing paren into the
comment, leaving the call unclosed. Moved onto its own line, matching how the other
wrapping snippets already close.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Expands and surrounds like `task`, for code that has to run off the caller's context.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>