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.

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.