non-functional commit. started refactoring memory into more useful
pieces

there will be different setup, init and handling of data, const &
stack (or temp) memory
typedarray-memory refactor for naive memory implementation done

3 memory types
  - naive: it has a list of pointers which point to an index in
           the data array. if the pointer value is zero, it has
           been freed.
           when we run out of space, a new data array is created,
           and all non freed values are copied over and their
           pointers updated
  - const: same as naive, can't be freed
  - stack: same as naive, but free frees up everything starting
           from the given pointer, not just that one value to
           which the pointer is pointing to

additional note: neither of the memory types actually know the
size of any of the segments allocated. all they know is where
each of them start and what's the next free data index.
this is because sometimes I want to resize a number to have
smaller length than I've allocated and I want to be able
to do this without allocating a new one. If I store the size
of the numbers in the actual allocated data, it's one
simple write to shrink the number's length, instead of a whole
new allocate.

also, when resizing the data, values are copied by the stored size
which means only the actual size will be used.

of course this means there is a hidden assumption in the resize
algorithm, that the **first** value is the size for the segment.

I intend to change this to work with a user given solution, or at
least make it more obvious. Perhaps store the length when allocate
and then allow to be changed.
Possible solution for not losing the reference to the ads & data objects after these are resized and replaced

I am not sure about the performance because of the many
object-property reads required, but I will nevertheless
finish the refactor with this solution and check the
benchmarks
Addition and integer cloning refactored.
Fixed bug of possibly changing data indeces.

There is a possibility of allocation triggering resize
of data array, which in turn might remove freed blocks
which can result in previously correct data indeces
changing
clear up, adding comment explaining repeated code.
Refactored subtraction.

Fixed various remaining bugs in typedarray-memory.
Refactored multiplication.

Using schoolbook algorithm.
This will have to be benchmarked against indutny's algorithm
which uses reduced number of array writes and extended with
some kind of Karatsuba implementation for larger numbers.
removed unnecessary requires.
varname change. thx ljharb.
some debugging/statistics code.

commented out because it slows down tests even more
variable name change.
forgot to remove this console.log call previously :-\
Fixed bug caused by previously freed data getting added to the
last bigit of a new sum.
Changed tests of subtraction and addition to use *temp*
memory storage.
Switched multiplication tests to temp memory storage
just a bunch of mess.
algorithms should be more or less ok, but the memory management gets corrupt even while testing addition. that's the simples algorithm, so that should make it easier to find the bug
baseconstant
random debug files which will be removed later
All tests pass.
File to contain most of debug functions.