Namespaced evm

This pullrequest aimed to solve a major problem with doctrine, but it ended up simplifying the entire EventManager.

## The doctrine problem

Doctrine doesn't have namespaces for events, therefore I developed a system with "double" dispatching, that was able to dispatch events from both variants at once. This why you might have noticed `onDaoCreated` when the event `Kdyby\Doctrine\EntityManager::onDaoCreated` was dispatched. 

Now that I think about it, it was a stupid solution, but it didn't seemed that way in the past. I believe everyone is using Kdyby/Events with namespaced events, and if not, he is not relying on the double dispatch, but is listening directly on the event he cares about.

## New behaviour

Both 

```php
function getSubscribedEvents()
{
    return ['App\Namespaced::onFoo', 'onFoo'];
}
```

still work, but calling `onFoo` (I'm talking here about `$evm->dispatchEvent('onFoo')` not `$service->onFoo()`) will not dispatch the namespaced variant anymore. You'd have to dispatch them explicitly 

- `$evm->dispatchEvent('onFoo')` -> `onFoo` 
- `$evm->dispatchEvent('App\Namespaced::onFoo')` (or `$appNamespacedService->onFoo()`) -> `App\Namespaced::onFoo`

=> only the exact match will be dispatched, never the other variant.

## New "namespaced EventManager"

Therefore new class was introduced, that creates proxy for doctrine (that will be used in kdyby/doctrine and it actually should have full BC). `EntityManager` and `Connection` will receive new `NamespacedEventManager`

```php
$em = EntityManager::create(..., new NamespacedEventManager('Doctrine\ORM\Event::', $evm), ...);
```

Listening on `postPersist` will still work, but now you can listen on `Doctrine\ORM\Event::postPersist`, which is better, because there will be no conflicts with other silimar libs using EventManager from doctrine (which were almost all the doctrine projects).

## Other refactorings

This also made simplifying the entire EventManager a possibility. I was able to remove the entire level of `namespaces` in internal structures, resulting in removal of several inherited `foreach` that were not needed anymore. Also I've been able to remove some other code, that I either didn't remember what it was for (let's hope there is a test for everything important! :smile: ) or seemed like a useless code. For example the mapping using `Nette\Utils\Callback` to and from closure object was a nice exercise, but totaly pointless. 

The code is still a bit complex around the sorting of listeners, because it has to solve priorities and inheritance, but the rest is now much more simple.