Options with mixed required and optional incompatible with nullable reference types

[Nullable reference types](https://docs.microsoft.com/dotnet/csharp/nullable-references) is a great new feature to help mitigate `NullReferenceExceptions` in production; however, when declaring options classes with both required and optional parameters, are incompatible.

Imagine an options class like so:
```csharp
public class GetOptions
{
[Option("path", Required = true)]
public string Path { get; set; }

[Option("out")]
public string? Out { get; set; }
}
```

This would satisfy CommandLine, but not the C# compiler with nullable types enabled because `Path` has to be set by the constructor. The compiler errs. We could add a `?` to the `string` declaration, but then we are effectively breaking the intent of declaring that `Path` will never be null downstream.

So we refactor the class like so:
```csharp
public class GetOptions
{
public GetOptions(string path)
{
Path = path ?? throw new ArgumentNullException(nameof(path));
}

[Option("path", Required = true)]
public string Path { get; }

[Option("out")]
public string? Out { get; set; }
}
```

However, because the options class type is still mutable, the constructor is not used and instead a default constructor is required.

I propose a model that allows both. And because this could be considered a breaking change (though perhaps not in practice), this could be opt-in: perhaps a marker interface for options classes or some other configuration. This would override the `IsMutable` check in `InstanceBuilder` and allow for non-default construction and property setters.

We also want to use this in a project that targets net45, and are willing to contribute changes that not only enable this behavior but also add back support for net45. Or perhaps you wouldn't mind a revision on 2.3.0 which we use now.