Substituindo None<T> na interface pública por Option.None

Foi realizada uma modificação na estrutura da ```Option``` para esconder a
'deselegância' do ```None<T>()```.

A ideia para esconder ```None<T>``` é a seguinte. Cria-se uma classe ```Option```, não genérica, e sem construtor público. Essa classe não genérica terá apenas uma instância que irá representar o ```None``` sem tipo, que só pode ser acessada pela propriedade estática ```Option.None```.

Adiciona-se a capacidade de converter ```Option``` em ```None<T>``` implicitamente. Como ```None<T>``` é subtipo de ```Option<T>```, automaticamente essa instância única de ```Option``` pode ser usada em qualquer contexto em que se espera um ```Option<T>```. Essa artimanha simula o conceito do Scala de "Option of Nothing". Estamos simulando o tipo ```Nothing``` com a ausência do type parameter, e fazendo manualmente a conversão de tipos. A conversão de tipos "mágica" acontece aqui:

```c#
public static implicit operator Option<T> (Option option)
{
     return new None<T>();
}
```

O compilador consegue criar um operador genérico, me dando acesso ao type parameter. Com isso, fica fácil retornar o exato ````None<T>```` que é necessário para a conversão, sem perder a sanidade da tipagem estatica.

Dessa forma, damos um nó no type system do c# e não precisamos criar os ```None<int>()```, ```None<string>()``` que não fazem sentido.

Um problema é que para implementar a conversão de ```Option``` em ```Option<T>``` tive de mudar ```Option<T>``` de uma interface para uma classe abstrata. Com isso, perdemos a covariância que havia anteriormente.