[MCC-116788][NRTM] Housekeeping - Added guard clauses using Code Contracts

@edandersen @mdsol/hypermedia-team Implemented guard clauses using Code Contracts.
I implemented guard clauses two versions (standard and code contracts version).
I've compliled some findings below. Let's compare the two implementations.

### Standard implementation (branch : feature/guard-clauses)
```
public void ToLower(string value)
{
    if (value == null) { throw new ArgumentNullException("value");
    return value.ToLower();
}
```
* Pros
    * Simple and easy implementation.
* Cons
    * Need to write a bunch of tests for guard clauses.

### Code Contracts version (branch : feature/guard-clauses-cc)
```
public void ToLower(string value)
{
    Contract.Requires(value != null, "value must not be null.");
    return value.ToLower();
}
```

* Pros
    * Have static checker.
    * Can write pre-conditions and post-conditions easily.
    * Let code speak more clearly like a document, especially for interfaces. Please see the following code.
    * Not needed to write  unit tests for guard clauses.
    * Have a lot of happy things. See more details
        * http://research.microsoft.com/en-us/projects/contracts/
* Cons/Problems
    * Require to install Code Contracts.
        * http://visualstudiogallery.msdn.microsoft.com/1ec7db13-3363-46c9-851f-1ce455f66970
    * Need to create interface contracts.
    * Can't write unit tests for interface contracts.
        * It means that code coverage declines. Please see code coverage result on CI.
    * Potable Class Library project requires to include `System.Contracts.dll` into the project.
        * http://social.msdn.microsoft.com/Forums/en-US/d806f1fc-ad09-4250-84a3-e4394606796d/portable-library-code-contract
    * Too heavy for small projects like crichton.

### Sample implementation of interface contracts.
Three layer application(which separates layer to presetation, domain and data then use DI container such as Gambit) has a problem when they are integrated because interface in C# can not state preconditions and postconditions of method.

C# interface is very ambiguous. For example..
```
public interface IUserRepository
{
    IEnumerable<string> Select(string key, int id);
}
```
* Can I pass `null` into `key` parameter?
* Can I pass negative number into `id` parameter?
* Is returning value is `null` or empty list when data is not found?

Interface contracts enable to describe more specified rules like a document.
```
[ContractClassFor(typeof(IUserRepository))]
internal abstract class IUserRepositoryContracts : IUserRepository
{
    public IEnumerable<string> Select(string key, int id)
    {
        Contract.Requires(key != null, "key parameter must not be null.");
        Contract.Requires(id >= 0, "id parameter must be positive number.");
        Contract.Ensures(Contract.Result<IEnumerable<string>>() != null, "Return value must not be null.");
        return default(IEnumerable<string>);
    }
}
```
It brought to 
* clarify all interfaces and clarify implementation both of Data layer side and Presentation layer side. 
* integrate code of Data and Presentation layer very smoothly,  
* remove redundant guard clauses (e.g. null check before or after calling method) in Presentation layer and also unit tests for guard clauses.