Decompile C# 14 implicit span conversions (first-class span types)

[siegfriedpammer]

Part of #829 (does not close it).

Implements decompilation of C# 14 implicit span conversions (first-class span types) and aligns the resolver with that spec. This PR started as a tests-only PR: the FirstClassSpanConversions fixture landed as an Assert.Ignore'd desired-output spec. The implementation followed on the same branch; the ignore is gone and that fixture is now the acceptance test.

What the decompiler now does

The C# 14 compiler lowers implicit span conversions to helper calls - MemoryExtensions.AsSpan(string), ReadOnlySpan<T>.CastUp<TDerived>, and the span op_Implicit operators - so decompiled code showed the lowered form: s.AsSpan(), ReadOnlySpan<Base>.CastUp(s), (ReadOnlySpan<int>)a, (Base[]?)a. CallBuilder now folds these back into conversions, riding the existing conversion machinery:

• the fold always builds an explicit cast carrying a ConversionResolveResult;
• consumption sites (arguments, returns, initializers, extension receivers, implicit-in arguments) make the cast implicit where the context allows;
• the overload-resolution recheck re-adds a cast when the bare argument would bind to a different overload. A deliberate str.AsSpan() overload disambiguation therefore canonicalizes to the equivalent explicit span cast (ReadOnlySpan<char>)str.

Gated by the existing DecompilerSettings.FirstClassSpanTypes (C# 14.0), so older language targets keep the helper calls.

Resolver alignment with the spec

Auditing the pre-existing span groundwork against the proposal found three deviations. Each is fixed and pinned by unit tests whose expectations were established by compiling probe programs with the C# 14 compiler:

• Type inference: lower-bound inference into a Span<T> target now makes an exact element inference (Span<T> is invariant) - M<T>(Span<T>, T) called with (Span<string>, object) fails inference (CS0411) instead of unifying to T = object.
• Betterness: ReadOnlySpan<E1> vs ReadOnlySpan<E2> is decided by implicit convertibility between the span types, not the element types - overloads on ReadOnlySpan<int>/ReadOnlySpan<long> are ambiguous (CS0121), not resolvable.
• Explicit span conversion: newly modeled, together with the spec rule that user-defined conversions are not considered between span-convertible types - Span<object> s = stringArray; is CS0266, not an implicit conversion via op_Implicit(object[]) plus array covariance. Span conversions are also excluded from extension receivers during method-group conversion (CS0123), while invocations keep them.

Tests

• FirstClassSpanTypes (pretty, green from the start): pins the C# 14 overload-resolution winners under span betterness.
• FirstClassSpanConversions (pretty, the acceptance test): every conversion shape - string to ReadOnlySpan<char> in argument, return, local-initializer and extension-receiver position; span variance via CastUp; covariant arrays; implicit-in arguments; and a by-value/in overload pair where the in keyword must survive decompilation to keep binding the same overload.
• 17 resolver unit tests in ICSharpCode.Decompiler.Tests/Semantics/ (inference, betterness, conversion classification, method-group receivers, and the in-binding matrix), each annotated with the Roslyn diagnostic it mirrors.

Full decompiler suite on Linux: 3099 passed / 0 failed / 44 skipped, and a clean -t:Rebuild of ILSpy.XPlat.slnf.

This PR was prepared by an AI agent (Claude) on behalf of @siegfriedpammer.