Object Versioning: return undefined when unproxying regular objs
Object Versioning: improved proxy tests, spec for proto behavior

also adds tests for what's not yet working correctly regarding proxies
as prototypes, so this commit adds red test cases
Object Versioning: pass objID when creating versioning handlers
Object Versioning: refactored lively...proxyFor slightly
Object Versioning: improved proxy behavior spec tests
Object Versioning: objectID in proxied objs + lively.ProxyTable

this way it's possible to not only insert all objects at most once
into the global object table and then always return proxies with the
same id for the same object, meaning
  lively.proxyFor(anObject).__objectID === lively.proxyFor(anObject).__objectID
holds, but further to actually return the same proxies, meaning
  lively.proxyFor(anObject) === lively.proxyFor(anObject)
now also holds.
Object Versioning: target object helper
Object Versioning: prototype link also via ID + Object Table

NOTE: this fixes the problems that the recently added test cases exemplified,
but currently still break some benchmarks... so the commit is expected to fail on travis

when a proxied object has another a proxied object as prototype, the traps of
the  object's proxy and the prototype's proxy fire. for example, when setting
a property of the proxied descendant object, the set-trap retrieves the original
object and attempts to set the property, which triggers the prototype's proxy to
trap the set and then set the property on the prototype. while it's possible to
detect for a trap that the receiver proxy does not correspond to this trap, it's
not possible (or not obvious / easy) to then set the receiver-proxy's target
without firing the prototype trap...

for this reason, and also because it seems more uniform, an object's prototype link
is now also virtual. that is, proxied objects now get a __protoID that can be used
to retrieve their actual prototype from the global object table in all proxy traps.
this also means to dispatch to the correct version of a prototype when the global
object table is changed.

note: when a proxy is used as prototype, it's does not seem possible to change that
prototype at runtime again (at least not with the current version of the ES6 proxy-shim,
see lib/reflect.js), it will probably be necessary to prevent actually using proxies as
prototypes. therefore, lively.versions.ObjectVersioning.wrapObjectCreate currently wraps
Object.create, stores the reference to the proxy's target object in a temporary prototype,
and exposes the wrapper as lively.create. the temporary proto-reference-prototype object
is expected to be used when the object itself gets proxied, which also means all objects
with proxied prototypes are expected to be proxied themselves...