Handle exts. in tokenizer and removed ExtensionContentCollector.

* Since the tokenizer can now identify the extension content and
  that strategy proved successful, this patch pushes that one step
  further by matching start and end tags and encapsulating it in
  the self-closing tag that the ExtensionContentCollector was
  doing thus far. There is no collection involved anymore since
  extension content is entirely encapsulated in this token.  So,
  there is no use for the ExtensionContentCollector anymore.

* If an xml tag is not a html5 tag, an older html tag, is a known
  installed extension, an include directive, or a native parsoid
  extension tag (<ref>, <references>), the xml tag is now
  converted to plain text.  This fixes parsing of text like:
  "x<y\n\na>b" which is no longer parsed as an xml-tag

* Fixed Util.arrayToHash to record "e: true" for each element 'e'
  of the array rather than '1'.  Also fixed all users to explicitly
  check for 'true' rather than a truthy value.
     Ex: var h = Util.arrayToHash(a);
         if (h[candidate] === true) instead of if (h[candidate])
  This is because if candidate is 'prototype' or 'constructor'
  h[candidate] will be a truthy value (functions), but not true.
  I realized this yesterday, courtesy marktraceur.

* A couple minor fixes and simplifications

* Change in parser test results:
  - 2 wt2wt tests green
  - 1 wt2wt test red (to be investigated)
  - 1 html2html test green

* This also speeds up parser tests since all tokens (and their attrs)
  are no longer repeatedly examined for matching extension tags.

Notes for next steps
--------------------
* There are 3 different ways how the non-html tags are handled:
  - natively-supported extensions like <ref>
    * tokenized in tokenizer in new scope and inserted back into
      top-level scope
    * go through stages 1 & 2 of the main pipeline
    * handled in ext.Cite.js where they get pulled out of stage 3.
    * separately post-procesed in a new stage 3 pipeline.

  - php-parser-supported extensions like <math>
    * content pulled out of tokenizer and hidden in a SelfclosingTag
      of type mw:Object/Extension.
    * processed by ext.core.TemplateHandler.js during stage 2 of the
      main pipeline:
      - content sent to php parser to generate html
      - html retokenized to tags and inserted back into token stream

  - <noinclude>, <includeonly>, <onlyinclude> directives
     * tokenized in a new scope and inserted back into the token
       stream if matched by the extension-tag production.
     * tokenized normally if matched by include_limits production
     * handled by TokenAndAttrCollector and processed by
       ext.core.NoIncludeOnly.js

* Next step: uniform handling of both natively-supported and
  php-parser supported extensions that effectively mimics a full
  expansion right upto to DOM building (either natively or via
  php-parser).  In a later step, possibly fold *include* directives
  into this abstraction if it lends itself to that.

Change-Id: Iecac76c27518a4690242e584c8c95ef363c749af