modified connection pool to properly remove closed connections
fixes #9:
* switched transaction isolation level from serializable to read_committed
* added tests for concurrent inserts and connection retrieval
* removed validate(): getMetadata() is expensive and - even worse - appearently cached (at least in mysql jdbc driver), so it's not suitable to detect whether a connection is still valid. instead connectionpool now uses the native isValid() method. Note that this change requires JDK 6
* changed connection pool to use a worker for cleanup of stale connections
* set last lease time of connection when it's returned, not when it's aquired (cleanup of stale connections uses this timesstamp to detect stale connections)
fixed some tests to run correctly with current ringo master (replaced scheduler with worker/semaphore)
fixed operator query to allow "equals(propname, null)" clauses
added distinct aggregation
fixed a bug that lead to only the first modification of an entity being persisted

source of the bug was the registration of visited entities in the transaction - if the entity would be modified multiple times without committing the transaction, only the first modification would be persisted (because updateEntity() would register the entity during its first call, and subsequent calls would return STATE_CLEAN).

although this commit fixes the bug, best would probably to modify storable's save to accept an additional array of visited entitites, which then would be passed to save/updateEntity in sqlstore (abusing the transaction for that is not a quite nice solution)

added engine dependency to package.json, updated to 0.1.1
removed invalid character
fixed usage of workers in connectionpool/transaction tests (current ringo master doesn't allow constructing a worker with an object literal as argument anymore)

fixed testConcurrency in connectionpool_test (missing assertion)
switched from ringo-storable to own implementation based on it:

* storable now uses states to precisely detect the various stages in the lifecycle of a storable instance (transient, clean, dirty, deleted)
* save() now uses a HashSet instance to track the visited storables in order to handle circular dependencies (before the transaction instance was misused for that purpose too). for this to work transient objects now also get a Key instance (before their _key property was only populated after persisting)
* save() now clears the _props object of the persisted storable - this ensures that mapped objects/collections are freshly populated (esp. with circular dependencies that's vital), plus it spares an often unnecessary re-population of the properties object.
* the entity object of a storable no longer has a _key property - instead a cache entry now consists of an array containing the key and entity object. this is imho cleaner/more explicit than the previous approach.
* various store methods now take a storable as argument because they need to access a storable's key, entity and/or props property
* added lifecycle unit test
added test for internal storable properties (_key, _props, _entity)
merged states branch into collectioncaching and adapted/tuned collections

 * collections now internally have an array of storable IDs instead of keys - this makes wrapping the standard Array methods much easier and probably boosts performance since the native methods are now used
 * if loading aggressive the collector populates the cache too
modified getEntity() to utilize the entity cache. this effectively replaces cached null entities with the ones loaded from db.