With the help of our new MiniParser, we only need to change the
parsing setup code in there, not touching all the related specs.

This helps to keep the parsing setup in one place and allow easier
changes to it when needed.  Each spec file only needs to call the
Helper::MiniParser.parse with a few arguments, simplifying the
setup code inside actual spec files.

Because the MiniParser.parse always returns Relations object, add
a #length method to Relations class, so that the tests that previously
checked the length of simple classes hash can now call the same method
on Relations object and continue passing.

This is really the main parsing class and shouldn't be buried deep
inside source/ dir.

So it's clear that it's parsing the documentation.
This way it's also clear that it goes along with the #process_doc
method.

Let the BatchParser only deal with the actual parsing part.
A separate BatchProcessor then deals with combining the parsed
source files into classes and doing all kinds of additional
processing on them.

The top-level JsDuck::App is now also simpler as it just saves
the @parsed_files and @relations into separate instance variables,
and can easily use them later without needing to ask list of
parsed files from BatchProcessor instance.

Both BatchParser and BatchProcessor are now singleton classes keeping no
state inside them - so they're also simpler to reason about.

Moving all the filter_class logic to GlobalMembers processor,
which can take care of the global member corner case without
disturbing the main BatchParser logic.

A silly copy-paste mistake.

Specific methods per each member type are no more needed - we can cover
it all with just a little bit of generic code.

Gets rid of all the duplicated warning logging code from the Tag classes
that use Doc::Subproperties.

Now we have completely removed the use of Doc::Subproperties from
Doc::Ast class.

Additionally process the @type tag.

There is no @tag for CSS Mixins, and therefore no way to define
a mixin name inside documentation - it can only be derived from code.

The :return field in the final hash will now be nil when no @return
tags was encountered - no more will it default to "undefined" type.

To achieve this, all #process_doc method get a third argument - the
position hash {:filename, :linenr}.

I considered several other options for passing this information
to the #process_doc method, but adding an instance variable for
all the tag classes didn't seem like a right way to go.

Just an ordinary refactoring.

Both the ImagesDir and ImagesDirSet now have #report_unused method.
No more is the unused images reporting part of #copy method.

Also take care to ignore the icon.png and icon-lg.png files inside
guides - these don't have to be reference by @img tag, but are
used automatically.

Include the Dimensions gem to retrieve image width/height meta-data.

Additional %w an %h placeholders to --img-tpl template.

Achieving this required extensive refactoring of how the images get
processed.  Previously the existance of images was looked up after
all the @img tag had been replaced.  Now the check for existance is
part of expanding the @img tag, so the check happens also for images
in guides, for which the check didn't occour previously as there is
no images copy step in there.

The old Images class has been replaced with ImageDir and ImageDirSet.

Added additional styles for the welcome page so that when it's
rendered from Markdown, the default result will look OK.

That's much better than the previous flickering where before performing
the search the dropdown was shown and after getting no results it was
hidden again.

Better to just show a message "Nothing found" - this will also make
clear to the user that the search found no results and didn't just fail
for whatever reason.

The Class#find_members(:local=>true) previously also returned
the hidden members.  This resulted from the fact that internally
it was using #global_by_id and #local_by_id indexes from MembersIndex
class.  As these maps are also used internally inside MembersIndex
I'm now exposing #all_global and #all_local methods which return
the arrays instead of hashes and both without any hidden members.

In commented out form, to be used when needed.

Instead of setting @multiline = true, the multiline tags now return
a tag containing {:doc => :multiline} from their #parse method.

Inside Doc::Parser the free text will only get appended to these
:doc=>:multiline tags plus a special :tagname=>:doc tag which grabs
all the documentation since the beginning of doc-comment up to the first
multiline @tag.

The Doc::Ast will later combine docs for classes and members, mainly
looking at the :tagname=>:doc, but also at :cfg and :property which are
a special case because they can contain subproperties, and also
:constructor which can be used as a splitter between class documentation
and constructor documentation.

Also the @constructor plays part in determining the name.
To make the two work together inspect the hash passed in to #process_doc
and only set the method name when needed.

Instead of returning a hash that gets merged into the final class/member
hash, the latter hash gets passed in as the first parameter and
the #process_doc can add desired fields to it.

This gives #process_doc the ability to check what's already inside the
final hash and then take action depending on that - not just blindly
writing over anything that happens to be there.

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.