Builtin go(fn, arg1, arg2, ...) starts a goroutine which run
fn(arg1, arg2, ...) in a new VM cloned from the current running VM,
and returns a job object that has wait, result, abort methods.

Builtin makechan(size) accepts an optional size parameter, makes a
channel to send/receive object, and returns a chan object that has
send, recv, close methods.

To be able to access *VM instance that it is running in for go()
and makechan(), now VM will always pass VMObj to and only to
BuiltinFunction as arg[0].

A goroutineVM is a VM cloned from the current VM in a shared way
that the cloned VM(the child) can access globals and constants of
the parent VM, but with its own stack and frames.

The cloned VM will be running with a specified compiled function
as the entrypoint in a new goroutine created by the parent VM.

In golang spec, "go" statement has no return value, which is not the
semantic here: we want "govm" returns a goroutineVM object which can
be used to wait, abort, or get result of the goroutineVM.

fix typo

VM will only pass its vmObj to builtin function that has needvmObj
equals true, so that normal builtin functions do not need to notice
the change.

The goroutineVM will not exit unless:
1. All its descendant VMs exit
2. It calls abort()
3. Its goroutineVM object abort() is called on behalf of its parent VM

The latter 2 cases will trigger aborting procedure of all the descendant
VMs, which will further result in d5#1 above.

Take below snipet as an example:

$ cat cmd/tengo/test.tengo
test1 := func() {
	v := 1
	test2 := func() {
		len(1,1,1,1)
		v++
	}
	test2()
}

test1()

----
before the fix:
$ ./tengo test.tengo
Runtime Error: wrong number of arguments in call to 'builtin-function:len'
        at -
        at test.tengo:7:2
        at test.tengo:10:1
----
after the fix:
$ ./tengo test.tengo
Runtime Error: wrong number of arguments in call to 'builtin-function:len'
        at test.tengo:4:3
        at test.tengo:7:2
        at test.tengo:10:1

with this commit:

1. builtinGovm() now accepts native golang function, but unlike
compiled functions which run in a cloned VM, native golang functions
do not need VM, they just run in a goroutine.

2. Parent VMs now have records of errors of all its descendent VMs.
A VM's error is a combination of the error of itself and all errors
of the descendent VMs, in another word, parent VM's error includes
all errors of the child VMs.

3. ErrVMAborted is no longer treated as runtime error.

now that "govm" does not always run function in VM, so "go" is better.

update docs to reflect the usage changes.

And now abort() on the same VM twice will not panic.

On a panic happens in a VM:
* the panic value along with both its script level and native level callstack
are recorded as run time error, its parent VM should examine this error.
* the panic will not cause whole program exits, but it does trigger the abort
chain, so that the VM in which the panic happens and all its descendent VMs
will terminate.

So panic only causes the descendent group of VMs to exit.
Other VM groups are not affected.

Export VMObj to std.fmt, so that fmtPrintln can get vm.Out to output
to a io.Writer per VM.

and nolonger hide ErrVMAborted

and nil child VM to gc after it is done

This reduce memory foot print significantly when there are large
number of small VMs running.