Access interceptor scope localizer 

This PR implements "scope localizing" proxies. This is an alternative to keeping a reference to a proxied object.

## Problem

The problem is that some objects may pass themselves to others. Here's a quick example to clarify when this happens:

```php
class Task
{
    public function run($args)
    {
        $this->args = $args;
    }
}

class TaskRunner
{
    public function runTask(Task $task)
    {
        return $task->run($this);
    }
}
```

When proxying this class with a value holder, the wrapped instance is passed to `Task#run()` (instead of the proxy):

```php
$taskRunner = $valueHolderProxyFactory->createProxy(new TaskRunner());

$task = new Task();

$taskRunner->runTask($task);

var_dump($task->args); // not the proxy!!!
```

We want our own wrapped instance to be passed to `Task#run()`, otherwise we may have instances of the proxy and of the original class floating around in the context.

## Solution

To avoid having a wrapped instance being passed around, we get completely rid of it.

Instead of keeping a reference to the original object, we can localize its scope. To do so, we can use the idea of @mnapoli of building ["friend objects"](http://en.mnapoli.fr/friend-services/).
Friend objects share internal state, but don't need to keep a reference to each other:

```php
class TaskRunnerProxy extends TaskRunner
{
    public function __construct(TaskRunner $taskRunner)
    {
        $this->property1 = & $taskRunner->property1;
        $this->property2 = & $taskRunner->property2;
        $this->property3 = & $taskRunner->property3;
        $this->property4 = & $taskRunner->property4;
    }

    public function runTask(Task $task)
    {
        parent::runTask($task); // no different instances put into play - we're safe!
    }
}
```

This example is over-simplified and covers only properties that are accessible from the scope of `TaskRunnerProxy`, but the concept is developed further in this pull request.

## TODOs

 - [x] ~~handle synchronization of `unset` if possible~~ (marked as limitation in #95)
 - [x] ~~handle synchronization of serialization/deserialization if possible~~ (marked as limitation in #95)
 - [x] handle PHP 5.3 compatibility in a more graceful way (will currently cause fatal errors)
 - [x] unit tests for code coverage
 - [x] ~~performance tests~~ (not relevant for access interceptors)
 - [x] documentation (see #95)
 - [x] ~~add a note about interfaces not being supported (maybe modify the constructor to allow runtime initialization via reflection?)~~ (interfaces CANNOT be proxied, since there is no `parent::` implementation for invoked methods)
 - [x] add `.phpt` tests for fatal errors
 - [x] add coverage for the newly introduced magic method overrides