C# does use the outer return type approach. This turns out rather useful for optimization, because C# draws a type-level distinction between reference types (class) and value types (struct). Often, a value type doesn’t require a heap allocation, and thus one can optimize an async method by returning a ValueTask.
C# differs from Rust, however, in that an async function allows duck-typing of its result. An async function can return any type implementing a visible GetAwaiter method (citation). An interface isn’t used because that would box the ValueTask. In Rust terms, returning a .Net interface is roughly equivalent to dyn Trait and duck typing is as close as .Net gets to impl Trait.
As you pointed out in your blog, the crux of the problem remains. If additional trait bounds are occasionally necessary, how should they be specified?
If the problem is limited to Send, I’d argue that the trait bound should be automatic. It’s perhaps unfortunate that it’s applied to inherent methods and free functions, but I’d argue it would be surprising if certain futures could be sent and others not. (As I understand it, Send is what allows the future to run on a multi-threaded executor–I’d expect that quality to apply to any future.)