string.Create for known length and string interpolation handler

[jnyrup]

string.Create currently has two overloads when you have some knowledge about the length of the final string.

string Create<TState>(int length, TState state, SpanAction<char, TState> action) takes as its first parameter the length of the final string and via the action gives you access to fill in the string.
You as a developer has the responsibility to fill out the entire string - not more, not less.

string Create(IFormatProvider? provider, Span<char> initialBuffer, [InterpolatedStringHandlerArgument(nameof(provider), nameof(initialBuffer))] ref DefaultInterpolatedStringHandler handler) takes as the second parameter a buffer Span<char> which is filled by the handler and ultimately copied into the final string.
Only the written parts of the buffer is copied to the final string.
(And if you out-grow the buffer one is rented from ArrayPool<char>)

I was looking at #50635 and the recorded review, but couldn't find if there ever was a discussion about a variant that populates the final string directly via a string interpolation handler?

The overload I'm imagining would look something like

public partial sealed class String
{
    public static string Create(IFormatProvider? provider, int length, [InterpolatedBuilderArgument("provider", "length")] ref InterpolatedStringBuilder builder);
}

Say you know that the final string will always be of length 24, this new overload will enable you to write

string.Create(null, 24, $"{a} {b} {c}")

compared to the existing overloads that either write to an intermediate buffer or are quite verbose.

string.Create(null, stackalloc byte[24], $"{a} {b} {c}")
string.Create(24, (a, b, c), static (span, state) => span.TryWrite($"{state.a} {state.b} {state.c}", out _));

string.Create(24, (a, b, c), static (span, state) =>
{
    state.a.AsSpan().CopyTo(span);
    span = span.Slice(state.a.Length);

    span[0] = ' ';
    span = span.Slice(1);

    state.b.AsSpan().CopyTo(span);
    span = span.Slice(state.b.Length);

    span[0] = ' ';
    span = span.Slice(1);

    state.c.AsSpan().CopyTo(span);
});

In https://www.reddit.com/r/dotnet/comments/15dr3gk/string_concatenation_benchmarks_in_net_8/juj40up/ I did some benchmarks, and it seemed the suggested overload could fill a gap between the existing overloads.

... or am I just missing an existing API that does exactly this?