Change Receive to work like Akka

## TL;DR
Akka and Akka.Net differs when it comes to Receive. This PR changes Akka.Net to be like Akka. 
Breaking change for inheritors of  `ActorBase`. 
No breaking change for inheritors of `UntypedActor`.
Since breaking changes are introduced I choose to be detailed about what I´ve done.

### Akka
Akka uses a [PartialFunction](http://www.scala-lang.org/api/current/index.html#scala.PartialFunction) for its receive function. If the partial function isn't defined for a message, the `unhandled` function is invoked. By default `unhandled` publishes a `UnhandledMessage` on the EventStream. If the user don't like the default behavior, `unhandled` can be overriden.

Akka´s `Receive` type is declared as: 
```scala
type Receive = PartialFunction[Any, Unit]
```
with the functions:
```
apply(Any message) : Unit
isDefinedAt(Any message) : Boolean
```

Pseudo code for handling a message is:
```c#
if(receive.isDefinedAt(message))
  receive.apply(message)
else
  unhandled(message)
```

### Akka.Net
In the current implementation of Akka.Net `OnReceive` has the signature `void OnReceive(object message)` and if the message is unhandled the user must manually call `Unhandled(message)` (which publishes to the EventStream) to signal that the message was unhandled. The user cannot override `Unhandled`.

Instead of having our own way of doing this, I would like Akka.Net to be like Akka and in order to do that we need to mimic the [PartialFunction](http://www.scala-lang.org/api/current/index.html#scala.PartialFunction) used in Akka. 

In Akka.Net the Receive is basically an `Action<object>`.
By changing it to `Func<object, bool>` we can mimic the functionality of Akka's Receive by combining `apply` and `isDefinedAt` into one function. This allows to have this type of handling in Akka.Net:
```c#
if(!receive(message))
  unhandled(message)
```


## Changes
The changes made are in line with how Akka works.
* Existing `Receive` was renamed to `UntypedReceive` (since it's only used in `UntypedActor`)
* Introduce new `Receive` delegate that mimics the Akka's partial function. A return value of `true` indicates that the message was handled, while `false` indicates it was unhandled.
```c#
public delegate bool PartialReceive(object message);
```
* In `ActorCell`:
  - Move functionality from `AutoReceiveMessage()` to `Invoke()` and introduce `ReceiveMessage()` to handle things previously handled by `AutoReceiveMessage()`
* In `ActorBase`: 
  - Refactor `protected abstract void OnReceive(object message)` to `protected abstract bool Receive(object message)`
  - Introduce `AroundReceive()` that is called from `ActorCell.ReceiveMessage()` and implements the pseudo code above.
  - Make `Unhandled()` virtual.
  - Remove obsolete code: `GetUnhandled()`, `IsUnhandled()`, `GetUnhandled()`, `lastMessageIsUnhandled`
* `UntypedActor` is still backwards compatible by these changes:
  - Reintroduce `void OnReceive(object message)`
  - Introduce `Become(UntypedReceive receive, bool discardOld = true)` to mimic the old one
  - Introduce `IUntypedActorContext Context` property.
* Introduce `IUntypedActorContext` (corresponding to Akka's `UntypedActorContext` trait):
```c#
public interface IUntypedActorContext : IActorContext
{
  void Become(UntypedReceive receive, bool discardOld = true);
}
```
`ActorCell` implements both `IActorContext` and `IUntypedActorContext` just like Akka's.

## Consequences
* **Breaking change**: The changes means a breaking change to inheritors of `ActorBase` and these needs to be modified (inheritors of `UntypedActor` do not need to be modified)
* Existing actors in `Akka.Remote` (`ReliableDeliverySupervisor`, `TransportSupervisor`, `ActorTransportAdapterManager`) and `Akka.FSharp.FunActor` now inherits `UntypedActor` instead of `ActorBase`. Someone with more knowledge of the code, should go through these and change to ActorBase (for guidance, see what was changed in `FSMBase`).