Reorganized var layout to prepare for heap implementation

Unfortunately the table implementation heavily uses power
of 2 sizing. This damages several potential heap implementaitons
that also use powers of 2 but must also store metadata related
to the allocation request. Usually this can be reduced to a size
field, which is stored somehow in most variables. It makes quite a
bit of sense to require the size to also be passed in deallocation
and remove this redundency. Usually this is a bad idea for C code,
because of the bookkeeping nescessary of the user, but for V it
makes a lot of sense. A simple malloc could then be written on top
that stores the size in the first space of memory.

To allow this, two things had to change. Strings must store their
size globally, and Functions must store the size of their bytecode.

The layout of functions was an easy fix, done by storing subfunctions
as vars in the var list. Not sure what to do with the extra 4 bytes in
the struct yet, but surely something else will come up.

Current function layout:
[       ref       ]
[    str bcode    ]
[ acount | vcount ]
[ bcount | stack  ]
[     var vars    ]

Strings could simply store their length after the reference count. This
has 6 bytes of overhead for any strings but is actually better than what
a naive heap implementation might do. Unfortunately the hack for using
type 0x4 for strings to enable direct dereferencing is broken.
Fortunately storing the length in only 2 bytes (which is standard now)
means that the type 0x6 can be used, but unfortunately the variables
must be rearranged.

After fiddling with the variable layout, I've found that the following
arrangement works very nicely and even simplifies the reference counting
functions. Anytime the lowest bit is set, there is a table in the first
word. If the higher 2 bits are set, the variable must points to a ref
in the lower word. The big downside, is now function pointers must be
aligned to 8 bytes, though this can be taken care of by gcc.

Here is the current var layout:
nil [00000000000000000000000000000|000]
tbl [   tbl tbl   |c|             |001]
num [          double num         |010]
obj [   tbl obj   |c|             |011]
bfn [   var f(t)    |   var f(a)  |100]
sfn [  tbl scope  |c|  var f(a,s) |101]
str [  off  |  len  |   str str   |110]
fn  [  tbl scope  |c|    fn fn    |111]