Extracted parse_method_name_singleton

parse_method is very complex and this was a huge chunk of it.
Extract parse_identifier

parse_statements has a lot of complexity, but parsing identifiers is almost
completely self-contained so it was easiest to extract.
Extract and fix consume_trailing_spaces

This loop could never run more than once (as peek_tk returns a Token
instance, not a class) so the loop was removed.
Extract parse_constant_body with minor refactor

Determining the end of the constant was the majority of parse_constant.

Handling the case of `CONST => value` now happens before creating the
Constant object that is immediately thrown away due to incorrect lexing.
This also avoids one unget.
Refactor duplicate method creation

AnyMethod.new was called from both the singleton and regular definition
sides which is not necessary.
Improve comment accuracy
Extract parse_method_name from parse_method

Like parse_method_name_singleton, parsing the method name for regular
methods is now self-contained.
Refactored method name parsing

Previously the singleton and regular sides each returned from
parse_method if the name was nil.  Now this is in one place.
Extract get_method_container

When a singleton method was preceded by a constant that wasn't the
current constant extra work was needed to create a new class or module
for the method to live in.  This is now extracted into its own method.
Extract parse_class_regular

Except for setting the line and offset of the class definition, parsing
of a regular class is now in parse_class_regular.  This simplifies
parse_class.
Extract parse_class_singleton

Parsing singleton classes is the other complex chunk of parse_class.
Parsing a singleton class on self was not extracted as it is already one
line.
Refactor setting class offset and line
Rename parse_method_name to ..._regular

parse_method_name_regular allows creation of a new method,
parse_method_name, that handles both regular and singleton method names.
Extract parse_method_name

The parsing that determines which name parsing method to call now lives
in its own method.  This will allow the two token_listener blocks to be
condensed into a single method.
Remove unused local variables
Extract parse_meta_method_name

This was the largest block of parse_meta_method.
Extract and refactor parse_comment_ghost

This handles parsing of a "ghost" method from a comment.  Some
limited refactoring was performed to set the offsets on the created
method.
Extract parse_comment_attr and refactor

This removes the other half of parsing a comment.  A small refactor was
performed to set the offsets for the created attribute.
Refactor parsing comments

Use co (short for code_object) for parsing a ghost method vs an
attribute.

Return from parsing an attribute before deciding if it is RW.