Created functional parsing strategy

Moved forward with generating bytecode as the seperation between
parsing and execution makes it much easier to debug and logic about.
To create a function, `fn_create` is called with source code, scope,
and arguments. To call a function, `fn_call` is called with the
function object and a table of arguments which are filtered based
on it's defined arguments but can still be retrieved with args.

Currently the parsing exists as a sort of mock push-down automata
through functions composed entirely of case statements based on current
token. I believe this, combined with several functions for defering the
last operation until the parser reaches the next token should be able
to generate decently efficient bytecode. However it does rely on
tail-call optimizations and requires all bytecode to use a destination
register (even for assignments to tables).

The full virtual machine is described in relative detail in `vm.h`.
It is designed for simplicity and minimalism without being overly
esoteric. The idea behind the VM, is that encodings to direct assembly
can be written easily as the language is ported to different
architectures.

Additionally
- `tbl`s and `fn`s functions now take in pointers, but there exist
  `var` functions which check for type.
- The macro `tbl_for` has been written to make table iteration easy.