The signature rendering code in frontend was duplicated in three
separate places. Now at one.

This way the class attribute @tagname corresponds to :tagname field
of the records produced by #parse_doc.

The #open and #close methods of HtmlStack now take StringScanner
as input and work at a higher level.

Throw away all enum members that aren't properties.

Fixes a crash when somebody attempts to add other types of members
that don't have a :type field, causing the #infer_type method to
fail.

This way the Tag#merge method will have access to both the filename and linenr,
which is useful for error reporting.

Previously the Merger introduced :linenr field, which was largely unused, except
for some tests checking it.  This resulted in exported JSON containing both :linenr
and :files fields - but the latter already has :linenr inside it.  So another good
step towards more consistency.

@class now always gets split up to multiple docsets, so there's no
need to loop through the members of a class docset, as there will never
be any.

This is currently the latest version.

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.