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.
Merge pull request #214 from jordansjones/master

Addresses issue #209.
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
Merge remote-tracking branch 'origin/master' into xamarin-mobile
Fix CallerMemberName attribute!
Add async/await support to iOS/Android projects
Make TargetActionCommandBinder compatible with Monotouch