Object Versioning: don't handle .apply & .call like primitives

some primitive functions expect real objects, not proxies. therefore,
we unwrap the thisArg and actual arguments to [native code]-functions,
but this should not include aFunction.call and aFunction.apply as the
thisArg is the actual function that will be executed and which might
not be primitive (but instead might contain arbitrary code where the
thisArg and arguments might better be proxied...)
Object Versioning: handle accessor functions in get- & set-traps

for example, in the set-trap, just doing
    targetObject[propertyName] = value
might fire a setter function, which then gets executed with an unproxied
thisArg (targetObject). therefore, we need to explicitly check for accessor
functions in both the set- and the get-trap.
Object Versioning: proper copy-on-write if obj from other version

previously, copy-on-write was naively done doing Object.freeze on all
objects in lively.CurrentObjectTable and then copying frozen objects in the
set-trap before writing into them.
this way, objects frozen once were actually frozen, even after going back to
their initial version... even though invariant versions might be not a bad
property, this should probably be done on the level of not versions not
individual objects (e.g. by not actually loading versions again, but by
creating new versions branching of them instead...).
however, using freeze is not really appropriate anyway as other code might
freeze objects as well and will expect objects to remain frozen (and not
instead result in mere copying). also, the current implementation actually froze
lively.CurrentObjectTable as well, which then prevented changing the global
object table and with that also effectively undo/redo..
Object Versioning: return proxy when proxying a proxy

code that is re-evaluated by printing the function and passing it to
eval immediately again (like it's done for the lively closures with
aMorph.addScript), actually passes code through eval and our source
transformations multiple times.

instead of source transformations that check carefully whether a literal
or specific Object is already wrapped into our proxyFor function, we just
let that function return the argument immediately whenever the argument
is already a proxy..
Object Versioning: removed dead debug code