Top level F# progams - implicit async and access to command-line args

# Top level F# progams - implicit async and access to command-line args

See https://github.com/dotnet/fsharp/issues/11631 and https://docs.microsoft.com/en-us/dotnet/csharp/fundamentals/program-structure/top-level-statements for more detailed explanation

In C# 9 we can write code such as this

```cs
using System.Net.Http

using var httpClient = new HttpClient();
var str = await httpClient.GetStringAsync("https://example.com/");
Console.WriteLine(str);
```

You can also access `args` from top level statements which you can't do from F#.

The existing way of approaching this problem in F# is:

There's no good way. See this comment https://github.com/dotnet/fsharp/issues/11631#issuecomment-855052325

## Pros and Cons

The advantages of making this adjustment to F# are: shorter, easier code. No need to remember code such as this

```fs
let theAsyncTask : Async = ...

[]
let main argv =
async {
do! Async.SwitchToThreadPool ()
return! theAsyncTask
} |> Async.RunSynchronously
```

The disadvantages of making this adjustment to F# are: I don't see real disadvantages.

## Extra information

Estimated cost (XS, S, M, L, XL, XXL): I don't know what the cost is.

Related suggestions: https://github.com/dotnet/fsharp/issues/11631

## Affidavit (please submit!)

Please tick this by placing a cross in the box:
* [X] This is not a question (e.g. like one you might ask on [stackoverflow](http://stackoverflow.com)) and I have searched stackoverflow for discussions of this issue
* [X] I have [searched both open and closed suggestions on this site](http://github.com/fsharp/fslang-suggestions/issues) and believe this is not a duplicate
* [X] This is not something which has obviously "already been decided" in previous versions of F#. If you're questioning a fundamental design decision that has obviously already been taken (e.g. "Make F# untyped") then please don't submit it.

Please tick all that apply:
* [ ] This is not a breaking change to the F# language design
* [ ] I or my company would be willing to help implement and/or test this

## For Readers

If you would like to see this issue implemented, please click the :+1: emoji on this issue. These counts are used to generally order the suggestions by engagement.

Start by reading the linked F# issue 11631 and the C# top-level-statements documentation to understand the proposed language behavior. Done would mean F# top-level programs can use implicit async operations and access command-line arguments without the existing EntryPoint and Async.RunSynchronously pattern.

Written by the indexing model from the issue text.