Fix/enhance KeyedResourcePool

Should address https://github.com/m3dev/octoparts/issues/66

If we want our `KeyedResourcePool` to work well with shared mutable state in general (not cause race conditions in things that it may not know about), we will need to synchronise our accesses to the underlying holder map as well as the conditional side-effecting logic that follows. For`KeyedResourcePool` this is either in the `getOrCreate` and the `cleanObsolete` methods.

This PR implements a naive (?) version of `KeyedResourcePool` called `SyncedKeyedResourcePool` (for now, after iteration we might just replace the old) that uses `synchronized` to do syncing as well as a failing test (passes under `SyncedKeyedResourcePool`).

Another way is to use an Akka actor, which is easier to reason about with (thus safer to maintain) in the long run. It will likely perform worse though (more method calls, construction Futures objects, thread-weaving, possibly others), though I don't know for sure without benching.

Note that all bets are off if there are multiple instances of `KeyedResourcePool` that may affect the same global state. 
While I think this implementation is technically correct (won't cause deadlocks or disastrous race conditions), it's pretty non-standard to have different methods synchronized on different objects. I would at least add some Scaladoc to clarify the concurrency semantics of this class.

To be honest I would rather use a global lock and sacrifice a (probably negligible) bit of performance for the sake of more understandable code and minimising the change of horrible heisenbugs. You could use a ReadWriteLock instead of `synchronized` to minimise performance impact.

By the way, a couple of fun facts about Symbols:
* You're already doing global locking anyway, just by calling the Symbol constructor. It has to use locking to ensure uniqueness of Symbol instances.
* Until Scala 2.10.1, there was [a bug](https://issues.scala-lang.org/browse/SI-6706) that meant that Symbols are not always unique, meaning that synchronizing on the Symbol instance would be completely broken.