Or, as somebody once said: You haven't really understood something
before you can explain it clearly. (He was right!)

 var anObject = function(){...} ();

I think you are reading it as

 (var anObject = function(){...}) ();  

i.e., assign the function value to the anObject variable first, then
call it. This is syntacitcally illegal, since the "var" keyword makes
it a declaration, and declarations have no value. The correct way of
reading it, however, is

 var anObject = (function(){...} ());

i.e., create anonymous function, call it, and assign the return value to
the anObject variable.

I had to read it twice too, to be sure what happened. I would have put
the parentheses there to disambiguate.

1 : create anonymous function (a "function expression"):
       function() { document.write ... return constructor}
2 : call the function from 1
2.1 : execute  document.write("1")
2.2 : create an anonymous function (a "function expression"):
       function() {document.write(" 2");}
2.3 : assign the result of 2.2 to the new global variable "constructor".
2.4 : return the value of the global variable "constructor". This is the
      result of 2.
3 : assign the result of 2 to the local variable "oneOff".
4 : use the value of the variable "oneOff" as a constructor with
    no arguments (new ...()). That is, create a new object and
    call the function with "this" pointing to the new object.
4.1 : execute  document.write(" 2")
4.2 : since nothing is returned, the result of the "new"-expression (and
      the result of 4) is the new object.
5 : assign the result of 4 to the variable "test".

...

I sometimes wish there was a clone method on all objects, but one can
make it oneself:

 Object.prototype.clone = function () {
    function myConstructor = function(){};
    myConstructor.prototype = this;
    return new myConstructor();    
 }