Eliminates a special case code used when calling the overrides
processor.

Added :[]= method to options to allow us setting values. Changed the
implementetion to use idiomatic instance_variable_get/set methods.

Because :name applies to all members, introduce a special merge_context
called :member, which expands to list of all known member types.

This allows us to do a larger refactoring in Merger class, eliminating
all the merge_like_* methods, and doing almost all the merging inside
the main #merge method.

Removing duplication of the docs and code comparison and merging code.

Introduce new Tag class just of this merging.

For now introduce the merge context of :method_like.

With bunch of refactoring in Merger class.

This way we can assure it always gets a default value of [].
Which is convenient as we often need to loop through the alternate
names, but checking the existance first is bordersome.

Having these default to nil is just fine.  Only when merging two classes
together, one needs to take the nils into account - so add some code for
that.

Defaulting to nil is just fine.

Leftovers from old times.

The general #do_merge method seems to already cover that.
Probably just a left over code from some ye old times.

@cfg, @property and @constructor can be followed by docs that are
part of the top-level documentation.  Instead of having the logic
for that hard-coded to Doc::Processor class, the latter only extracts
the general :doc, and the Tag classes themselves append top-level docs
to this when needed.

I always intended \z, but mistakenly wrote \Z instead.

For some reason I had always thought \Z is the end of string in Ruby,
but it turns out \z is actually the end of string while \Z will match
right before a newline at the end of string if there happens to be one.

This little difference caused quite an unexpected behavior in one corner
case where the code example is on just a line before the @tag.

Don't pass them through the TagRegistry.  Either way it's a hack, but
doing it through TagRegistry is only adding an extra layer of
indirection.

This class is doing with the processing of @new and @since tags already,
so it might as well take care of this @new related task.

This gets rid of the special #options= method in Tag::New and
TagRegistry.

The missing return value is now just nil, not "undefined".

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.

Splitting up the humongous Link class into more managable pieces.

The DocFormatter constructor now takes two parameters - relations and
options, instead of passing the relations in separately.  It then
instantiates LinkRenderer and passes it to Link and AutoLink
constructors.

The LinkRenderer is still too heavily coupled to Link and AutoLink,
as these call all the methods of LinkRenderer, but the situation is
much better overall.

Previously all auto-linked classnames had to begin with uppercase char,
but that's not really needed as we only replace namespaced classnames
anyway.

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.