Blocks passed out of actors leak the abstraction

An example:

```ruby
require 'celluloid'

class MyActor
  include Celluloid

  def ask_for_something(other)
    a1 = current_actor
    other.do_something_and_callback do |value|
      self.receive_result value # Oops, this is wrong, it's the wrapped object
      current_actor.receive_result value # Oops, this is also wrong, it's the receiving actor
      a1.receive_result value # This is overly explicit, requires knowledge of the scope leakage and is very easy to leave out without an obvious sign that it's wrong
    end
  end

  def do_something_and_callback
    ...some operation...
    yield :foo
  end

  def receive_result(result)
  end
end

a1 = MyActor.new
a2 = MyActor.new

a1 = ask_for_something a2
```

I propose we should ensure that the scope of any closures be the ActorProxy, rather than its wrapped object, at least when blocks are passed to methods on other actors, where we stand a chance of making this possible.

For a stripped-down example of this general case: https://gist.github.com/2fc26d60d59fd64ea72e

Anyone have any smart ideas?