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. 
I think there is still one possible race condition because a thread can be creating a new value while another is cleaningObsolete (and +=/-= assignment is not atomic). Thus, additional synchronization is required :smiling_imp:, e.g. the `case None` block. This increases the chances of a deadlock... so we should be careful.

What about switching back to a `TrieMap`, while synchronizing the `getOrElseUpdate` / `-=` operations on the current key? We can still optimize for the 'cruise' mode (e.g. gets only)

`holder.getOrElse(key, key.synchronized{holder.getOrElseUpdate(makeNew(key))})`

`if (!validKeys.contains(key)) {key.synchronized{holder -= key}; onRemove(value)}`

@cb372 This is hard stuff and I may be missing something, please review too :bow: