Consider custom parsers/converters/handler for types?

I would love to be able to do:

```c#
public class Options
{
[Option('o', "out", Required = true, HelpText = "Output file")]
public string OutFile { get; set; }
[Option('d', "duration", Required = false, Default = "1:00:00", HelpText = "Duration")]
public TimeSpan Duration { get; set; }
[Option('e', "endpoint", Required = true, HelpText = "IP Endpoint (:)")]
public IPEndPoint Endpoint { get; set; }
}
```

Where I can use types like `TimeSpan` and `IPEndPoint` or any other type. Ofcourse, we would need to be able to specify a parser/converter/handler/whatever that takes the value and converts it to the desired type. I imagine it be like:

```c#
public class Options
{
[Option('o', "out", Required = true, HelpText = "Output file")]
public string OutFile { get; set; }
[Option('d', "duration", Required = false, Default = "1:00:00", HelpText = "Duration", Converter = typeof(MyTimeSpanConverter))]
public TimeSpan Duration { get; set; }
[Option('e', "endpoint", Required = true, HelpText = "IP Endpoint (:)", Converter = typeof(MyIPEndpointConverter))]
public IPEndPoint Endpoint { get; set; }
}
```

Next these 'converters' should implement something like an IConvert that defines a method `T Convert(string value)` where they take a string (the commandline argument) and convert to the desired type. Another option would be to not use the attributes but be able to specify handlers like:

```c#
Parser.Default
.Register()
.Register()
.ParseArguments(args)
....
```

Would that be something that you would consider? (Maybe not exactly following the idea given above, but the broader idea of being able to handle custom types).

Nenhum arquivo de implementação ou teste é mencionado. Comece em Parser.Default e ParseArguments, depois rastreie como as strings de opções são convertidas atualmente e compare as abordagens propostas baseadas em atributos para Converter e registro. O trabalho estará concluído quando tipos personalizados como TimeSpan e IPEndPoint puderem ser tratados por meio de uma API definida e testada.

Escrita pelo modelo de indexação a partir do texto da issue.