Load options dynamically by System.Type only working for verbs.

I have an architecture where first, an Options base class is parsed and based on one parameter, I need to parse specific Options. These Options are loaded dynamically and since they are loaded dynamically, I can't use the generic method overloads of ParseArguments and the overload with params System.Type[] types, works only for verbs?. This once simple and goal oriented Library, unfortunately became unnecessary complex.

In Version 1.x I could pass the specific instance e.g. MyClassOptions and it would parse just fine.

```cs
using System;
using System.Collections.Generic;
using System.Linq;
using CommandLine;

namespace CmdTest
{
class Program
{
static void Main(string[] args)
{
// args = -c MyClassOptions -s mySpecificOption

//....

// First Parse base options, load specific options depending on parameter of this instance.
// Parse specific options while using type from reflection.

//....

Parser parser = new Parser(with => with.IgnoreUnknownArguments = true);
var result = parser.ParseArguments(args, typeof(MyClassOptions)).
MapResult(x => x, NotParsedFunc);

MyClassOptions options = (MyClassOptions) result;

// Not working, because the public ParserResult ParseArguments(IEnumerable args, params Type[] types);
// overload only parses verbs now...

Console.WriteLine(options.SpecificOption);
}

private static object NotParsedFunc(IEnumerable arg)
{
throw new Exception(arg.First().Tag.ToString()); // Exception is thrown
}

public class OptionsBase
{
[Option('c', "class", Required = true, HelpText = "Class that should be loaded dynamically.")]
public string Classname { get; set; }
}

public class MyClassOptions : OptionsBase
{
[Option('s', "specificoption", Required = true, HelpText = "Specific Option for my class to load.")]
public string SpecificOption { get; set; }
}
}
}
```

Start at Parser.ParseArguments(IEnumerable, params Type[]) and compare its handling with verb parsing. Reproduce the sample using OptionsBase and MyClassOptions, then verify whether dynamically supplied types parse inherited and specific options as intended.

Written by the indexing model from the issue text.