Prevent reset notification from firing twice

Reset is called from SuppressChangeNotifications so we don't
need to explicitly do it from the derived collection.
Merge pull request #211 from niik/duplicate-reset-notification

Prevent reset notification from firing twice
Resolves issue #209

Exit early in RoutedViewHost when in Design Mode.
Added "XDESPROC.EXE" (VS2012 Design Mode) to RxApp list of design
environments.
Also fixed an issue in RxApp where checking for design mode was testing
against full path of assembly instead of just the assembly name.
Add iOS and Android Xamarin.Mobile DLLs
Add a UINavigationController that follows an IRoutingState around
Add an initial hack at an iOS ISuspensionHost
Handle when the user force-quits the app
Switch to looking up via UIViewController so it's easier to use the RouterUINavigationViewController
Add the suspension host to default registration
First hack at getting suspend/resume running
iOS 4.x and higher never call WillTerminate
Merge pull request #214 from jordansjones/master

Addresses issue #209.
Add missing PropertyBinding in MonoTouch
So many hax to make this work :-/
OrderedComparer - simple comparer chaining

When creating derived collection you need to provide an ordering function.
Writing these comparators is easy enough when you only need to deal with a
single property, ie (```(x,y) => x.Show.CompareTo(y.Show))```).  But they
can get complex in a hurry if you need to take multiple properties into
account. The OrderedComparer helps with that by adding some syntactic
sugar for chaining multiple comparisons together.

Say you have a list of employees (yup, I have zero imagination) and you
whish to sort these by descingin Salary, descending Age and ascending
Name (ignoring case). Today you'd probably write something like this:

```int CompareEmployees(Employee x, Employee y) {
  int ret = 0;

  ret = -(x.Salary.CompareTo(y.Salary));

  if(ret != 0) {
    return ret;
  }

  ret = -(x.Age.CompareTo(y.Age));

  if(ret != 0) {
    return ret;
  }

  return StringComparer.OrdinalIgnoreCase.Compare(x.Name, y.Name);
}```

With OrderedComparer you'd write that like this:

```OrderedComparer<Employee>
  .OrderByDescending(x => x.Salary)
  .ThenByDescending(x => x.Age)
  .ThenBy(x => x.Name, StringComparer.OrdinalIgnoreCase);
```

LINQ-style chaining. The end result is a reusable generic comparer, an
IComparer<Employee> instance which you can use for sorting not only
derived collections but also generic lists or any other type which relies
on ICompare<T>.

The OrderedComparer<T> class is only syntactic sugar in itself since the
ThenBy and ThenByDescending methods are implemented as extension methods
on the IComparer<T> interface. The OrderedComparer<T> only exists to
provide a nice starting point but you could also start from an existing
comparer.

```// This is a stupid comparer
StringComparer.OrdinalIgnoreCase
  .ThenBy(x => x, StringComparer.Ordinal);
```
Type inferred starting point for anonymous types

Create comparers by type inferring them from generic IEnumerables.
Add OrderedComparer files in platform projects
Work in progress portable library.

ReactiveCommand and ReactiveAsyncCommand moved to RxUI-Core
Renamed ReactiveUI_Portable to ReactiveUI.

Added _Net40 to .Net 4.0 projects.
Moved Validation.cs into RxUI-Xaml.
Updated projects to reference the Portable Library.
Lazy in its own file.
Linked Command classes and Interfaces into RxUI-Xaml for .Net 4.0
Fixed compile errors.

Fixed InternalsVisibleTo.
Temporarily handle unit test detection by returning false.
Change the namespace for PropertyChanging classes to work around namespace collision on .Net45. Need to think about the best way to handle this.