Adding INITIALIZER rule to tree

Makes type checking much easier for init declarators
Not printing number of children when printing syntax tree

It was too noisy
Fixing symbol_search's return type

Was void*, should be struct typeinfo* as that's the value for keys in
symbol tables.
Adding helper for type checking
Adding token_print() back from d6cfdec, with category printing
Adding token literal categories to map_type()
Renaming to typeinfo_expr() to type_check()
Adding typeinfo globals for token literals' basic type representation
Quieting warning on Travis
Removing newlines from rules.c
Using typeinfo_compare() during insertion for functions

Rather than typeinfo_list_compare() which is handled in the former
comparison, in addition to the return types of the function.

Fixing bug caused by typeinfo_new() assigning true to the function's
pointer flag because of a pointer existing before the identifier of the
function. There are better fixes, but 120++ does not have function
pointers.
Explicitly casting in get_rule() macro so iter->data can be sent
Adding unknown_type global type comparator
Curly brace cleanups
Refactoring leaf handling into get_typeinfo() for type_check()
Allowing new local variables to override those in inherited scopes

By searching only the top scope while inserting, rather than the entire
stack of scopes.
More formatting for errors
Adding class_type comparator

Setting comparators values in get_typeinfo() so type_check() can
override various fields as needed (i.e. pointer flag).
Adding get_production() helper to return tree node for given rule

Currently used when handling the new operator
Performing type checking in a second tree traversal

Easier to grok logically. Necessitates type_check() perform a pre-order
search of the entire syntax tree, type checking on expressions where
necessary, and noop for non-expressions. Avoids tricky business with
initializers and race to symbol insertion. Also necessitates handling of
nested scopes when encountering function definitions, but avoids
trickiness with implementing type checking concurrently with the
tree_preorder() application of handle_function().

Note that the INITIALIZER production rule must be explicilty ignored
when encountered during recursion of a declarator.

Type checking works for simple assignments of literal values and
symbols, as well as calls to the new operator.