Parser supports instance variables
Backfilled a test for class variables in the parser

Got a little excited with the last commit. Initially I wasn't going to write
the rules in the parser, but it was so simple that it seemed folly to do not
go ahead and do it while I had context. Then I discovered that there was a
weird issue where adding support for parsing an instance variable broke
parsing regular varibles. Here's my best attempt at breaking this down for
future me and other interested parties:

an assignment looked like this:

SOME_NAME whitespace? = whitespace? (some ruby expression)

So then I changed that to be:

(some ruby expression) whitespace? = whitespace? (some ruby expression)

Adding that ... somehow broke "foo = :bar" in the parser. My best guess is that
there's a conflict in some rules and it finally came to a head when trying to parse
either

@foo = :bar

or

foo = bar

Where the first expression (e.g.: "foo" or "@foo") could be one of several composite
types.

So that didn't seem very good. I added an explicit type for a variable -- something that
could be assigned to, so that the rule for assignment looked like:

(variable_name) whitespace? = whitespace? (some ruby expression)

Even with that change, it still wasn't very happy. It is likely a result of the fact
that a variable can optionally have @, @@, $ before it.
Instance / class variables can be capitalized