Freeze on match customization

Addresses #120 by introducing a new customization that freezes specimens based on a set of criteria.

### Usage

The `FreezeOnMatchCustomization` uses the `IRequestSpecification` abstraction as a way to match the incoming requests with the frozen specimen. For example:

```csharp
var fixture = new Fixture();
var freeze = new FreezeOnMatchCustomization(
    typeof(string),
    new PropertySpecification(typeof(string), "Foo"));
fixture.Customize(freeze);
```

This will assign the same string value to _all properties of type `string` named `"Foo"`_.

Multiple matching criteria can also be combined using the `OrRequestSpecification`. Here's an example:

```csharp
var fixture = new Fixture();
var freeze = new FreezeOnMatchCustomization(
    typeof(string),
    new OrRequestSpecification(
        new PropertySpecification(typeof(string), "Foo")
        new ParameterSpecification(typeof(string), "bar"))); 
fixture.Customize(freeze);
```

When no matching criteria are specified, the `FreezeOnMatchCustomization` behaves like the current `FreezingCustomization`, that is it will only match by _exact type_. More concretely:

```csharp
var freeze = new FreezeOnMatchCustomization(typeof(string));
```

is the same as saying:

```csharp
var freeze = new FreezeOnMatchCustomization(typeof(string), new ExactTypeSpecification(typeof(string));
```

### Follow-ups

The are a few things I deliberately left out until after I gather your feedback:

- Since the `FreezeOnMatchCustomization` effectively supersedes the existing `FreezingCustomization`, I propose we obsolete it and rename the `FreezeOnMatchCustomization` to simply be `FreezeCustomization` for consistency.
- I'll add the XML documentation once the feature is finalized.

I look forward to your comments.
> How does the choice of Type for targetType relate to Postel's law?

The reason why I chose `Type` for the freezing target is that the existing [`FreezingCustomization`](https://github.com/AutoFixture/AutoFixture/blob/master/Src/AutoFixture/FreezingCustomization.cs) already works with types and I wanted to maintain a familiar API.

Generally, I value the _robustness_ of a function with liberal (i.e. least specific) parameters as long as that doesn't cloud its intended usage. In this case, I mean to communicate that the customization freezes an object given its type. Making the constructor accept a more general parameter (`object`, for example) could create the assumption that you can directly pass an instance and have it be treated as the _frozen value_.
Of course, we could go ahead and run a series of heuristics on the `object` argument and make the customization behave differently when it receives a `Type` than any other kind of object. However, that would overly complicate the implementation (at the risk of making it more brittle) for it gains, IMO.