Add string extensions for colorizing text

This is a resubmission of an original PR which adds the option of creating a `ColorToken` using a string extension method.

You can now call 

```csharp
ColorConsole.WriteLine(
    "Press".Colored(ConsoleColor.Gray),
    " Esc ".Colored(ConsoleColor.Red),
    "to exit".Colored(ConsoleColor.Gray));
```
or
```csharp
ColorConsole.WriteLine(
    "Press".Gray(),
    " Esc ".Red(),
    "to exit".Gray());

```

EDIT (@adamralph): Also adds a `WriteLine(params ColorToken[] tokens)` overload.
I don't think anyone would ever write `.Color(null)` or `.Color()` since neither serve any purpose. Due to the implicit conversion from `string` to `ColorToken` you can just write:-

```C#
ColorConsole.WriteLine(
    "Press ",
    "Escape ".Color(ConsoleColor.Red),
    "to exit.");
```

or, as you say, it's far more likely that people will use the color specific extensions, i.e.

```C#
ColorConsole.WriteLine(
    "Press ",
    "Escape ".Red(),
    "to exit.");
```

Having the parameter as nullable is important, not for static coloring but dynamic coloring, e.g.

```C#
ConsoleColor? color = null;
if (someCondition)
{
    color = ConsoleColor.Red;
}

ColorConsole.WriteLine("Some text".Color(color));
```

In fact, given that the color specific extensions exist, I think the dynamic setting of color is the *only* reason that the `Color(ConsoleColor)` method needs to exist, further pressing point that noone will ever write `.Color(null)` or `.Color()`.

Furthermore, optional parameters are really just surrogates for overloads so it's reasonable to ask whether we would consider providing a parameterless overload `Color()` and that would be my preference rather than an optional parameter. The only purpose of this method would be a conversion from `string` to `ColorToken` with a null color but since the implicit operator is already defined and does exactly that, the overload would be redundant.

Ultimately, the only use of having a `ColorToken` with a null color is to allow that specific token to inherit its color either from text color set in the user's console configuration or during a call to `ColorText.Colaesce(ConsoleColor)`. I guess there *could* be a case for having the parameterless `Color()` overload in case the implicit conversion isn't obvious to people and they get stuck wondering how to allow the color token to inherit its color. Moreover, this wouldn't be an issue if there was an extra member on the enum, `ConsoleColor.Inherit`, which made it obvious. We could choose to introduce our own enum for that purpose in which case we could remove the nullability of color across the board, but I'm not sure that's a good idea. I quite like the reuse of the built in enum.

Wow - I find myself writing war in peace over the discussion of a seemingly tiny point! Still, there's no huge rush with any of this and it's interesting to thrash it out.