Instead of returning a single value, a hash must be returned which will
get merged with the resulting class/member hash.

The advantage being that one @tag can generate multiple fields in the
final class/member hash.

The main class is now called Versions and it handles the generation of
@since and @new tags.  The actual importing work gets done by Importer
class, which we now mock out when testing the Versions class logic -
no more testing of private methods.

This way it's clear that it's not really related to the items in doc/
directory.

Another cleanup.

To clean up the lib/jsduck/ dir even more.

This was used to keep an array of classes in their original order, but
now that the tests use the resulting Hash instead, it's no more needed.

Aggregator now only exposes #aggregate and #result methods.  The result
now returns a Hash instead of Array - a change which caused a change in
lots of specs, but we're now better off as the specs rely less on
positional indexing in #result and instead look up classes by name.

To clean up extra cruft from the main /lib/jsduck dir.

So they're all called using the pattern:

    SomeClass.new(@relations).process_all!

Didn't notice the specs failing because the files of installed
jsduck got loaded instead of the jsduck files in repository.

To unify the naming with other classes doing similar stuff.

In BatchParser use the Aggregator#classes to retrieve the result
instad of the old #result method.  The latter is now used only in
testsuite.

Instead make the #nest method return two values where the list of
warnings is the second value.

The Tag#parse method can now return also an array of hashes instead
of just one.  And the @enum uses this to generate both :class and :enum.

Let the #hw method return it's original return value, which is the
DocScanner class - then it chained with one of the DocScanner
methods like #look or #match.  The only exception being #default_value
method which belongs to StandardTagParser and can't be therefore
chained from #hw method - but that's just a one little exception
we can live with.

The parsing now takes a config parameter to turn on/off parsing of Type
and Name sections.

This cleans up the DocScanner class considerably as all those complex
methods are now in StandardTagParser, leaving the DocScanner with
basics such as #look and #match, plus the big #standard_tag.

For now, it parses the following pattern:

    @tag {Type} [some.name=default]

That's the only place it's used in.

These are no more called by any Tag classes.

When somebody needs to parse \w+ pattern - then it should tell so
explicitly, but #ident will now parse the actual identifier pattern.

The member_reference parsing has now moved completely inside Inheritdoc
class.