half-done PoC of typed channels
add selfChannel and createChildren
clean it up a little

- remove Parent trait and use ChannelList to describe the parent
- remove ugly hack and switch to erasure-based dispatch to the channels
- add parentChannel
- make ChannelRef a value class
replace Channel[] trait with simple Tuple2 for nicer syntax
change Recv[] from partial to total function

- also change :=: to :+: for faster typing pleasure on US keyboards
add tests for parentChannel
add ChannelRef.narrow[]
add narrowing from ActorRef to ChannelRef
add polymorphic channels

- channel[T <: ChannelList] takes a WrappedMessage[T] => Unit function
  because there cannot be a typed sender reference (which type would it
  have?)
- ChannelRef[T] allows forwarding of WrappedMessage[T] (and nothing
  else; keeping the sender is essential)
- move ActorRef.narrow implicit into the package object
- do not accept top-level Channels which send to their parent
add typed ask support
add check for same-erasure channels
add check that all channels were declared
add verification of ping-pong chains

- basic principle is that if we get a reply of type T1 and our channels
  allow us to reply to such a message with type T2, then the target
  needs to support that as well, and so on.
- due to this, forwarding will have to be restricted; but it might well
  be that forwarding will not be completely safe in any case
major facelift: -!-> and -?-> appear

- rename projects to akka-channels and akka-channels-tests
- move implementation into akka.channels.macros package
- remove picking up ActorRef as sender (or none at all)
- factor out logic to make different façades acting upon Future[] or Any
  so that -!-> and -?-> can complement the traditional <-!- and <-?-
- the new operators are easily distinguishable from !/? and the
  rightwards-pointing go with the flow and compose better, let’s try
  them out
finally found out how to splice types

- add Helpers.weakTT for producing a WeakTypeTag from a tpe
- use that to simplify Ask.scala (the others will follow)
- and this way make forwarding actually work
the great beautification

- reify() all trees, no bricolage
- use rediscovered c.TypeTag factory to splice in calculated types
- give meaningful names to type parameters and humunguosly explode val
  names
the great wrapping

- you can tell/ask WrappedMessage and it will be checked precisely and
  sent naked
- ask() always returns Future[WrappedMessage[_ <: ChannelList, LUB]]
- FutureOps.lub will collapse such a Future into Future[LUB]
- sending a Future[WrappedMessage[_, _]] to a ChannelRef will check it
  precisely and send naked
add ReplyChannels[T] to model fully polymorphic channel forwarding

this enables

class F[T <: ChannelList : TypeTag](t: ChannelRef[T]) extends Channels[T] {
  channel[T] { (x, snd) => x -?-> t -!-> snd }
}

which can then be extended to bunching, filtering, transforming of
message streams.
first cut of the docs for typed channels
require “Actor with Channels” by using self-typing