Add the ability to register new types with service locator

This patch adds the ability to register types with the service locator, so
that RxUI itself can use it without first waiting for a service locator to be
set up.
Create dispatch classes to subscribe to notifications for objects

This is the first step towards creating an extensible WhenAny /
ObservableForProperty, for being able to add MonoTouch KVO support. This
creates a new interface that, for a given object and property name, knows how
to create an IObservable to notify when that property changes. We do this for:

* INPC objects
* Reactive objects (IRNPC)
* DependencyObjects
* POCO objects as a fallback.
Enable ObservableForProperty and WhenAny for all classes

This commit uses the infrastructure built up earlier to add the ability to use
ObservableForProperty and WhenAny to any object - it is determined at runtime
what kind of ICreatesObservableForProperty to use.
Hack in DepProp observer in RxApp. Ugly.
Test WhenAny with a DependencyObject
Don't need this anymore
This doesn't need to be so specific
Move IViewForViewModel down to RxUI core
Deprectated, use CreateDerivedCollection
Add basic interfaces for command binding

Add the raw methods to bind a command to a view object, in a similar fashion
to ICreatesObservableForProperty. The high-level extension methods will use
these methods via the service locator to implement command binding.
Implement Command Binding

Add the implementation for Command Binding, building off of the previous
commit. The intended syntax (once some RxApp plumbing is finished), will look
something like:

// Binds vm.FooCommand to view.FooCommand
this.BindCommand(ViewModel, x => x.FooCommand)

// Binds vm.FooCommand to view.FooControl
this.BindCommand(ViewModel, x => x.FooCommand, x => x.FooControl)

// Binds vm.FooCommand to view.FooControl, and passes vm.Baz to the
// ReactiveCommand every execution
this.BindCommand(ViewModel, x => x.FooCommand, x => x.FooControl, x => x.Baz /*Param*/)

// Binds vm.FooCommand to view.FooControl, and calls Foo() every invocation to
// determine the CommandParameter
this.BindCommand(ViewModel, x => x.FooCommand, () => Foo() /*Param*/);
Add support for binding Commands to arbitrary events
Finish off the public interface for CommandBinder
Make BindTo use WhenAny internally
Sketch out Property Binding

Implement the implementation interfaces for property binding, allowing to
declaratively bind ViewModels to Views. This commit also shuffles around some
methods to make implementing this easier.
Implement two-way binds
Implement the rest of the bindings
Implement public interface for Property Binding
Version bump to 4.0
Xaml generates Fields as its backing store for controls :-/