Allows a TaskActor to get type specific messages into it's next[T](t:T) method

This uses a Typeclass Handler[T] found in TaskActor to get specific types into a TaskActor's ```def next(t:T)``` method. These types are delivered via the Message.msg type which is defined to be ```<: java.io.Serializable```. A TaskActor must mix in MessageHandler[T] and define def next(t:T). For example:
```
class SOLBolt(conf : Configs) extends TaskActor(conf : Configs) with MessageHandler[Baz] {
...
  def next(baz: Baz): Unit = {...}
}
```
Additionally the TaskActor must include an implicit TypeClass like to following 
```
object SOLBolt {
  implicit object SOLBazHandler extends Handler[Baz](
  {
    case b:Baz =>
      b
  }
  )
}
```
A restriction is the TaskActor can't define multiple ```def next(t:T)``` methods if this particular TaskActor expects a variety of different types. This could probably be improved upon and should perhaps just deal with JSON types between TaskActor's.
This is required because Handler[T] is a TypeClass. It allows new TaskActor's that we've never seen to add handler's without API changes. Read about typeclasses [here](http://danielwestheide.com/blog/2013/02/06/the-neophytes-guide-to-scala-part-12-type-classes.html). Scala TypeClass's always follow this pattern (using implicit parameter). It may be possible to have multiple types using something like case class Handler[F[_]] or using higher kinded types but I'm still experimenting with this idea. What we have seems much simpler than akka TypedChannels which I also looked into.