Add HostedCommandHandler helper class

[fredrikhr]

Following the discussion in #1344 we have detected flaws in the implementation of the UseCommandHandler extension methods.

This PR adds a new helper class HostedCommandHandler which works similarly to CommandHandler by creating instances of ICommandHandler that forward the call to InvokeAsync(InvocationContext) to a handler instance constructed by the .NET Generic Host DI-system.

UseCommandHandler is removed by this PR.

Test have also been updated to use the HostedCommandHandler instead of UseCommandHandler.

The test have also been adjusted to better reflect design principles using the .NET Generic Host. In particular this involves having options-classes that hold the values bound from command-line. The handlers get an injected IOptions<T> instance from which they read bound command-line argument values.

/cc @leonardochaia, @Gronex

A minimalistic example of using DI-bound handlers would look like this:

public static class Program
{
    public static Task<int> Main(string[] args)
    {
        var rootCommand = new RootCommand
        {
            Handler = HostedCommandHandler.CreateFromHost<MyCommandHandler>()
        };
        var parser = new CommandLineBuilder(rootCommand)
            .UseHost(CreateHostBuilder)
            .Build();
        return parser.InvokeAsync(args);
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureServices(services =>
            {
                services.AddTransient<MyCommandHandler>();
                services.AddOptions<MyAppOptions>()
                    .BindCommandLine()
                    ;
            })
            ;
}

class MyCommandHandler : ICommandHandler
{
    private readonly MyAppOptions options;

    public MyCommandHandler(IOptions<MyAppOptions> options) : base()
    {
        this.options = options.Value;
    }

    public Task<int> InvokeAsync(InvocationContext context)
    {
        /* Do something here */
    }
}

class MyAppOptions { /* Add properties here which match Options/Arguments from command line */ }

closes #1344

[fredrikhr]

Currently this PR only constructs the Handler from .NET Generic Host DI.

We could extend the logic to do the construction in the following order:

1. Attempt host.Services.GetService<THandler>()
   1.1. If successful, get or create a ModelBinder<THandler> and use UpdateInstance on the constructed handler instance.
   1.2. Return instance
2. Get or create ModelBinder<THandler>
   2.1. Call CreateInstance to create THandler from BindingContext
   2.2. Return instance

This would allow the handler to be constructed both from the hosted DI-system as well as from Added services from the command-line binding context. The additional call to UpdateInstance would also allow the ModelBinder to bind command-line arguments directly to the handler instance instead of requiring an Options type, this would simply be a shortcut to the normal .NET Generic Host way of doing things.