.NET: Consider implementing functional workflow definition API

[lokitoth]

See #4238 for primary issue.

Motivation and Context
The functional API would be a stepping stone between single-agent use and the full graph API. Users write workflows as plain async functions -- no executor classes, no edges, no builder patterns.

This seems like it would be preferred for, e.g. F# users.

[Arithmomaniac]

Durable Task Framework already provides a model of how you do this in C#. Their orchestrators and activities map conceptually to the workflow and executor, respectively. Would we consider an implementation with the same basic shape? (code example courtesy Copilot)

// Executors: unchanged, the existing base type.
public sealed class FetchData(string id) : Executor<string, DataResult>(id)
{
    public override async ValueTask<DataResult> HandleAsync(
        string url, IWorkflowContext ctx, CancellationToken ct = default)
        => new DataResult(url, $"Data from {url}", 200);
}

public sealed class Transform(string id) : Executor<DataResult, string>(id)
{
    public override ValueTask<string> HandleAsync(
        DataResult d, IWorkflowContext ctx, CancellationToken ct = default)
        => new($"[{d.Status}] {d.Content}");
}

// The workflow: pure imperative C#. The control flow IS the graph.
public sealed class DataPipeline : IWorkflow<string, string>
{
    public async Task<string> RunAsync(IWorkflowContext<string> ctx, string url)
    {
        var raw     = await ctx.RunExecutorAsync<FetchData, string, DataResult>(url);
        var summary = await ctx.RunExecutorAsync<Transform, DataResult, string>(raw);

        if (!summary.Contains("[200]"))
            return $"{summary} (INVALID)";

        // fan-out: no edges, just WhenAll
        var (a, b) = await (
            ctx.RunExecutorAsync<ScoreA, string, int>(summary),
            ctx.RunExecutorAsync<ScoreB, string, int>(summary)).WhenAll();

        // HITL
        var ok = await ctx.RequestInfoAsync<string, bool>($"Approve (score {a + b})?");
        return ok ? $"{summary} (APPROVED)" : $"{summary} (REJECTED)";
    }
}

// Run it — no builder, no edges.
var wf = new FunctionalWorkflow<string, string>(
    new DataPipeline(), executorProvider, hitlHandler);

string result = await wf.RunAsync("https://example.com");