Add Adam's design thoughts.
WIP. Start writing parse tree generator for tests.
WIP. Just a checkpoint in case I fuck shit up.
Change to typed vector implementation.

Before, all vectors were basically just a void* that automatically got
realloced, and were used like this:

```C
// If you wanted to make a vector of ints:
struct vector *vec = vector_init(sizeof (int));
// Need to make a temporary variable because we need to pass a void* to
// vector_push.
int x = 0;
vector_push(vec, &x);
// To get the value, need to convert it to an int* and then dereference
// it.
printf("%d\n", *(int*)vector_get(vec, 0));
```

Now you can define vectors with a given type and use those in a more
intuitive way:

```C
// declareVector is a macro that declares the struct and the functions
// that operate on it.
declareVector(int_vector, int)
// defineVector is a macro that defines the implementation of the
// functions declared by declareVector. They need to be split up because
// otherwise, if you use the vector type across many files, you might
// have multiple definitions of the same functions, which would cause
// errors when you try to compile.
defineVector(int_vector, int)

...

struct int_vector *vec = int_vector_init();
vector_push(vec, 0);
printf("%d\n", vector_get(vec, 0));
```
Declare vector types in vector-types.h and make generateParseTree more general.

Declare vector types in a separate file so that they can be shared
easily between files. I did this because test.c and parser.h both use
the stringVector type now.

Before, generateParseTree had special cases for (identifier ...) and
(number ...) nodes. Now, anything that's not a lisp-like form get's
added to the data vector in the parseTree struct, instead of the
children vector.

So, if you do pt(a (b c)), it will generate a struct parseTree that
looks like:
{name="a", children=[{name="b", children=[], data=["c"]}], data=[]}
(assuming that C could print out structs like that, and that [...]
represents a vector).
WIP. Start working on code generator.