Handling compound assignment operators

Requirement int or double operands for arithmetic; int for modulo;
unsupported error for bitwise.
Fixing bug with std::string initialization

The class.type of an instance of a std::string is "string", not
"std::string", which is the class.type of the symbol for the "built-in"
string class.
Handling puts-to << operator
Handling constructor invocation

Mostly copied from function invocation. Should refactor eventually.
Refactoring to use class_member() over get_class()

Stricter search for CLASS_NAME constrained to DIRECT_DECL(4|5) subtree,
which represents a class::name or class::class declaration, the latter
specifically in *definitions* of class member functions.

Prior use of get_class() required the first child node of a
FUNCTION_DEF(1|2) to exist (and be the return type) as it skipped over
it and explicitly checked the next node. With the addition of handling
constructor definitions, the former function definition also needed to
be handled, but lacked the child because ctors are a special case
with an immutable and unwritten return type.

Trying to add a faux type failed when the tree was freed because it the
insertion caused a double free.
Removing _ctor suffix on ctor names

Since the ctor is inserted into the class's symbol table, and symbol
masking is now allowed, there is no worry about conflicting with the
class symbol's key, as it is only searched for while outside its own
scope.

Yay no more ugly string reallocations.
Moving DIRECT_DECL6 because numeric order
Passing key to handle_function() rather than obtaining inside

Since ctor's key is the class name and other functions' keys are their
identifiers, and this distinction is made at the production rule level.
Handling type check of constructor definitions

Class definitions are also handled during symbol table population (case
added to handle_node() and return type set in typeinfo_new()) to
facilitate this.
Adding tree_push_front()

And refactoring to share internal tree_leaf()
Removing unused helpers
Checking for null more
If defining a function, recurisvely search for function symbol

Only insertions which are not function definitions should be constrained
to the top of the scope stack.
More null checking!
Recursing on compound_statement in function definition rather than n2

Necessary for FUNCTION_DEF1 rule where its n1 because there's not
initial type. What a headache.
Fix for common int main() but no return

Assuming void return (or no return at all) is 0 if expecting an integer
because of this way too common case in the example code.
Fixing missing scopes

For some reason I was shallow copying my type when recursing into
handle_init_list(), which is unecessary because of the deep copy
performed when entering handle_init(), and was severely breaking classes
because it was losing the scopes. Ugh.
Adding default public scope and declaring default public constructor

But only when necessary.
Adding braces to compound_statement so that empty functions aren't null

Otherwise the lack of any statement (like in an example!?!) caused that
tree node not behave well, since we were assigning an internal node but
with not children.
Fixing type errors in examples