Had to change the logic a little for checking for missing function name.

For some reason the docs app had an hard-coded minimum with.
This severely impacted the usability on iPad where the browser window
width was smaller than our min-width, resulting in text going off the
screen and there being no way to get to it.

Add a smoke test to ensure we'll catch such a thing in the future.

Let the @key be aut-created from @pattern instead - requirering each
BooleanTag implementation to define @pattern.

This will help with writing Custom Tags tutorial, where I can introduce
the @pattern field first.

Hosting the file inside the wiki repository instead makes much more sense.

No more special casing for config options subsections - the Tag::Cfg
just defines different rules for splitting members into subsections.

Instance/Static subsections are now only defined for properties and
methods.  Events and CSS members will be listed without subsectioning.

Add additional :toolbar_title setting to @member_type config.
Use it to assign shorter toolbar titles to the member types that
otherwise have a bit too long titles.

For this whole thing to work the list of memberTypes is passed to the
Docs app, which then uses the list to create toolbar buttons.

That's just needless.

Take into account all the registered property-like tags when deciding
whether to render in method or property style.

Custom member types can now finally be detected.

The titles and ordering of the sections is now defined within the Tag
class of each member type.  Ordering works similarly to the ordering
of #to_html method calls.

Titles are no more hardcoded in Render::Class.

Divide members into two broad categories:

 - method_like
 - property_like

The @param Tag merger is now set up for all method_like members - so
all such members could have parameters.

The Default and Type tags are set up for all property_like members -
so all such members will have the :default and :type fields processed
and merged.

This should lay ground for the future with user-defined member types.

Add more extensive documentation for Tag#html_position.

Why are we skipping it on that case?  Possibly to avoid creating
the :html_type field, but currently we are creating it anyway, which
defeats the whole purpose of skipping the parsing, plus we lose warnings
of bad typedefs.

Now we get the type warnings also when doing export. And the code
is simpler. Win-win.

Handle it at the Format::Class level again - but this time do it through
the Format::Doc#skip_type_parsing setter method.

Because the concrete CSS member types are hard-coded anyway it's better
to have this hard-coded logic in one spot, not scattered around several
Tag classes.

The instantce of Format::Subproperties however is now created inside the
Format::Doc class, which also has methods #format_subproperty
and #format_type that delegate to Format::Subproperties class.

Passing in the formatter is enough - we can extract relatons from that.

The Format::Class is now much-much cleaner.

To avoid passing the Relations object explicitly around, add an
accessor to Format::Doc - so we can just pass an instance of the
formatter around and TypeParser can get the relations object
from the formatter, which it gets passed anyway and which already
includes the relations.

Turn Shortener from singleton into normal class - simplifies testing,
and in the context of Tag::Doc it only gets instantiated once anyway.

Also rename :shortDoc to :short_doc - a more Rubysh name.

Cleaning up the top-level JsDuck namespace.

The rendering of @cfg, @property, @css_var subproperties got lost during
the previous refactorings.

Add a special Subproperties tag class to render the :properties field.

Param, Return and Throw classes now perform calls to
Subproperties.render* methods as needed.

Additionally rename the Param tag @key from :param to :params.
Otherwise we have no handler for the :params key to render the HTML.

Move the rendering of params, return and throws inside that.

Move the whole rendering of class sidebar inside that.

The Renderer class is now way cleaner.

Instead of having three fixed places for positioning the docs, the Tag
classes are now sorted based on a numeric #html_position value.  For
start I'm defining three constants, but any other values can also be
used.

For now we're also introducing a special html_position=:doc.
But the next step will be to get rid of that.

The HTML rendering is now done in two parts:

1. Tag#format method is called, passing the DocFormatter.
   This is where Markdown to HTML conversion happens.

2. Tag#to_html method is called, which must just return HTML.
   No more can formatter be used inside #to_html.

This simplified the passing of DocFormatter instance to Tags -
no more do we need to inject the formatter inside Tag classes,
instead we can just pass it as a parameter.  With this we remove
the single remaining state object from Tag class.

A minor enhancement to improve compatibility with Closure Compiler.

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.