The old --meta-tags options is now replaced with --tags, that
pretty much behaves the same, except the classes themselves
need to be implemented differently.

Have two types of accessors:

 - get* methods for accessing one tag by some kind of key.
 - <plural noun> methods for accessing arrays of tags.

So the tag classes are now in JsDuck::Tag namespace.

For now the injection of @assets is implemented as specific to @aside
tag.  Needs cleaning up in the future.  But now finally all the old
meta-tags have been replaced with new builtin tags.

For now I'm leaving out the tooltip text implementation for
the @new tag - needs some further refactoring.

Lots of changes, but they're all pretty much the same - replacing
foo[:meta][:static] with foo[:static].

Also extract base class for @removed and @deprecated.

This way the to_html only needs to take one parameter and the
formatter can be passed to tags only once, when starting the
HTML generation, instead of passing it every time when invoking
the #to_html method.

Instead of passing the value of current tag and then separately setting
the @context variable, we now just pass the context from which the
tag implementation needs to extract its value by itself.

Implement @multiline property in base Tag class and use it in @deprecated
to consume the multiline docs after @deprecated.

As the @template generates custom HTML, the Tag classes can now have
a #to_html method and @html_position attribute.

Both get inherited from BooleanTag.

In so doing we need to also copy over the :protected property when
doing inheriting and expansion of accessors.

Builtins::Tag now supports the @signature attribute like MetaTag.
For now the signature logic is duplicated as both tag groups support it.

In search data and class data export the data for builtin tags is
added to :meta field, so the frontend logic can stay the same.

On the good side, @private no more needs to be duplicated in both
member[:private] and member[:meta][:private] - just the former will do.

No more assume everything's coming from doc - also look at the
code data and merge stuff from there that didn't came from doc.

Make use of this to implement @evented and @accessor as BooleanTag
subclasses.

Use it as a base for @hide and @inheritable.

Tags can now define #key attribute and #process_doc method - the
latter will take care of combining the results of #parse.

Detection of @hide and @inheritable is now entirely done in
corresponding Tag classes.

After messing a lot with trying to move AstNode object creation
straight to JsParser class, I discovered that it might not be the best idea.

Most of these have now been moved inside AstNode class.
Including the Serializer and Evaluator.