Warn when function type passed to interpolated string

[T-Gro]

Warn when function value is used as interpolated string argument

Adds a new warning FS3882 when a function or delegate value is used as an interpolated string fill expression — a common mistake where the user likely forgot to apply the function to its arguments.

let f x = x + 1
let s = $"{f}"       // FS3882: This expression is a function value...
let s = $"{f 42}"    // OK

What's in this PR

• New warning gated behind LanguageFeature.WarnWhenFunctionValueUsedAsInterpolatedStringArg (F# 11.0)
• Detects both F# function types (isFunTy) and delegate types (isDelegateTy) — System.Action, System.Func<>, etc.
• Fires for both string-typed and FormattableString-typed interpolated strings
• Suppressible via #nowarn "3882"

Bootstrap fixes

The new warning correctly caught real issues in the compiler's own codebase:

• DependencyGraph.fs — was interpolating function parameters ({unpacker}) instead of meaningful strings
• FSharpProjectSnapshot.fs — was interpolating a callback {f} where {fileName} was intended

Tests

14 new tests covering: lambdas, partial application, _.Member shorthand, named functions, delegates (Action/Func), multiple holes, FormattableString, format specifiers, #nowarn suppression, and language version gating.

[github-actions]

❗ Release notes required

---

✅ Found changes and release notes in following paths:

Change path	Release notes path	Description
src/Compiler	docs/release-notes/.FSharp.Compiler.Service/10.0.300.md
LanguageFeatures.fsi	docs/release-notes/.Language/preview.md

[T-Gro]

I just realized that the warning would work best if we could already hint for suggesting [<CallerArgumentExpression>] as the alternative.
I came across it when bootstrap build after this feature reported this new diagnostic for the compiler codebase itself:

fsharp/src/Compiler/Utilities/DependencyGraph.fs

Lines 340 to 348 in 01bad01

	failwith $"Expected exactly one dependency matching {unpacker} but got: %A{dependencies |> Seq.toArray}")
	[<Extension>]
	static member UnpackMany(dependencies: 'NodeValue seq, unpacker) =
	let results = dependencies |> Seq.choose unpacker
	if dependencies |> Seq.length <> (results |> Seq.length) then
	failwith $"Expected all dependencies to match {unpacker} but got: %A{dependencies |> Seq.toArray}"

[Happypig375]

Consider also applying the warning to delegate types too, which are effectively also functions.

[Happypig375]

Should this warning also apply to .ToString() and calling the string function? How about printf formats with %A or %O?

[T-Gro]

Should this warning also apply to .ToString() and calling the string function? How about printf formats with %A or %O?

Conceptually, those would make sense as well - but they need more design when it comes to the compile vs runtime split and figure out what to do with delayed (currying) or delegated (e.g. fields on a record) invocation.

= Not in this PR, but feel free to expand in the related suggestion for example 👍 .