Align relaxed-<select> implementation with spec, in line with review comments

Move selectedcontent cloning from TreeBuilder to DOM-side subclasses:
the optionElementPopped() hook now walks the live DOM to find the
ancestor <select> and its <selectedcontent>, check selectedness, and
clone option children — rather than relying on parser-tracked state.
Implemented in all four subclasses (DOMTreeBuilder, SAXTreeBuilder,
XOMTreeBuilder, BrowserTreeBuilder).

Remove all dead IN_SELECT / IN_SELECT_IN_TABLE mode code (handlers,
constants, end-tag special cases) — with <select> “relaxation”, those
modes are never entered.

Fix resetTheInsertionMode to skip past <select> elements on the stack
instead of incorrectly returning IN_BODY — an enclosing td/th now
correctly yields IN_CELL, an enclosing table yields IN_TABLE, etc.

Align start-tag handling with the spec:

- HR: use generateImpliedEndTags() instead of manual isCurrent/pop
- OPTION/OPTGROUP: remove redundant pop loops (spec says parse error
  only), add missing reconstructTheActiveFormattingElements for
  optgroup, fix optgroup to check both option and optgroup in scope
- SELECT: check fragment case first, remove generateImpliedEndTags
  from nested case, add framesetOk = false
- Table elements (caption, tbody, tr, td, th): treat as stray start
  tags, removing the old IN_SELECT_IN_TABLE dual-scope check

Fold </select> end tag into the standard block-element group (with
div, fieldset, button, etc.) — the dedicated resetTheInsertionMode
call is no longer needed.

Add spec URLs and verbatim spec-text comments throughout all
<select>-related code sections — for traceability and review-ability.

Author: sideshowbarker

gwt-src/nu/validator/htmlparser/gwt/BrowserTreeBuilder.java

@@ -475,20 +475,97 @@ private static native void removeChild(JavaScriptObject parent,
         }
     }
 
+    private static native JavaScriptObject getNextSibling(
+            JavaScriptObject node) /*-{
+                        return node.nextSibling;
+                    }-*/;
+
+    private static native String getLocalName(
+            JavaScriptObject node) /*-{
+                        return node.localName;
+                    }-*/;
+
+    private static native boolean hasAttribute(
+            JavaScriptObject node, String name) /*-{
+                        return node.hasAttribute(name);
+                    }-*/;
+
     @Override
-    protected void cloneOptionContentToSelectedContent(
-            JavaScriptObject option, JavaScriptObject selectedContent)
+    // https://html.spec.whatwg.org/multipage/form-elements.html#maybe-clone-an-option-into-selectedcontent
+    // Implements "maybe clone an option into selectedcontent"
+    protected void optionElementPopped(JavaScriptObject option)
             throws SAXException {
         try {
+            // Find the nearest ancestor <select> element
+            JavaScriptObject ancestor = getParentNode(option);
+            JavaScriptObject select = null;
+            while (ancestor != null && getNodeType(ancestor) == 1) {
+                if ("select".equals(getLocalName(ancestor))) {
+                    select = ancestor;
+                    break;
+                }
+                ancestor = getParentNode(ancestor);
+            }
+            if (select == null) {
+                return;
+            }
+            if (hasAttribute(select, "multiple")) {
+                return;
+            }
+
+            // Find the first <selectedcontent> descendant of <select>
+            JavaScriptObject selectedContent = findDescendantByLocalName(
+                    select, "selectedcontent");
+            if (selectedContent == null) {
+                return;
+            }
+
+            // Check option selectedness
+            boolean hasSelectedAttr = hasAttribute(option, "selected");
+            if (!hasSelectedAttr && hasChildNodes(selectedContent)) {
+                // Not the first option and no explicit selected attr
+                return;
+            }
+
+            // Clear selectedcontent children and deep-clone option children
             while (hasChildNodes(selectedContent)) {
                 removeChild(selectedContent, getFirstChild(selectedContent));
             }
-            JavaScriptObject clone = cloneNodeDeep(option);
-            while (hasChildNodes(clone)) {
-                appendChild(selectedContent, getFirstChild(clone));
+            for (JavaScriptObject child = getFirstChild(option);
+                    child != null; child = getNextSibling(child)) {
+                appendChild(selectedContent, cloneNodeDeep(child));
             }
         } catch (JavaScriptException e) {
             fatal(e);
         }
     }
+
+    private JavaScriptObject findDescendantByLocalName(
+            JavaScriptObject root, String localName) {
+        JavaScriptObject current = getFirstChild(root);
+        if (current == null) {
+            return null;
+        }
+        JavaScriptObject next;
+        for (;;) {
+            if (getNodeType(current) == 1
+                    && localName.equals(getLocalName(current))) {
+                return current;
+            }
+            if ((next = getFirstChild(current)) != null) {
+                current = next;
+                continue;
+            }
+            for (;;) {
+                if (current == root) {
+                    return null;
+                }
+                if ((next = getNextSibling(current)) != null) {
+                    current = next;
+                    break;
+                }
+                current = getParentNode(current);
+            }
+        }
+    }
 }

src/nu/validator/htmlparser/dom/DOMTreeBuilder.java

@@ -356,19 +356,87 @@ protected Element createAndInsertFosterParentedElement(String ns, String name,
     }
 
     @Override
-    protected void cloneOptionContentToSelectedContent(Element option,
-            Element selectedContent) throws SAXException {
+    // https://html.spec.whatwg.org/multipage/form-elements.html#maybe-clone-an-option-into-selectedcontent
+    // Implements "maybe clone an option into selectedcontent"
+    protected void optionElementPopped(Element option) throws SAXException {
         try {
+            // Find the nearest ancestor <select> element
+            Node ancestor = option.getParentNode();
+            Element select = null;
+            while (ancestor != null) {
+                if (ancestor.getNodeType() == Node.ELEMENT_NODE) {
+                    Element elt = (Element) ancestor;
+                    if ("select".equals(elt.getLocalName())
+                            && "http://www.w3.org/1999/xhtml".equals(
+                                    elt.getNamespaceURI())) {
+                        select = elt;
+                        break;
+                    }
+                }
+                ancestor = ancestor.getParentNode();
+            }
+            if (select == null) {
+                return;
+            }
+            if (select.hasAttribute("multiple")) {
+                return;
+            }
+
+            // Find the first <selectedcontent> descendant of <select>
+            Element selectedContent = findSelectedContent(select);
+            if (selectedContent == null) {
+                return;
+            }
+
+            // Check option selectedness
+            boolean hasSelected = option.hasAttribute("selected");
+            if (!hasSelected && selectedContent.hasChildNodes()) {
+                // Not the first option and no explicit selected attr
+                return;
+            }
+
+            // Clear selectedcontent children and deep-clone option children
             while (selectedContent.hasChildNodes()) {
                 selectedContent.removeChild(selectedContent.getFirstChild());
             }
-            Node child = option.getFirstChild();
-            while (child != null) {
+            for (Node child = option.getFirstChild(); child != null;
+                    child = child.getNextSibling()) {
                 selectedContent.appendChild(child.cloneNode(true));
-                child = child.getNextSibling();
             }
         } catch (DOMException e) {
             fatal(e);
         }
     }
+
+    private Element findSelectedContent(Element root) {
+        Node current = root.getFirstChild();
+        if (current == null) {
+            return null;
+        }
+        Node next;
+        for (;;) {
+            if (current.getNodeType() == Node.ELEMENT_NODE) {
+                Element elt = (Element) current;
+                if ("selectedcontent".equals(elt.getLocalName())
+                        && "http://www.w3.org/1999/xhtml".equals(
+                                elt.getNamespaceURI())) {
+                    return elt;
+                }
+            }
+            if ((next = current.getFirstChild()) != null) {
+                current = next;
+                continue;
+            }
+            for (;;) {
+                if (current == root) {
+                    return null;
+                }
+                if ((next = current.getNextSibling()) != null) {
+                    current = next;
+                    break;
+                }
+                current = current.getParentNode();
+            }
+        }
+    }
 }

src/nu/validator/htmlparser/impl/ElementName.java

@@ -1428,7 +1428,7 @@ public void destructor() {
 public static final ElementName SELECTEDCONTENT = new ElementName("selectedcontent", "selectedcontent",
 // CPPONLY: NS_NewHTMLElement,
 // CPPONLY: NS_NewSVGUnknownElement,
-TreeBuilder.SELECTEDCONTENT);
+TreeBuilder.OTHER);
 public static final ElementName SLOT = new ElementName("slot", "slot",
 // CPPONLY: NS_NewHTMLSlotElement,
 // CPPONLY: NS_NewSVGUnknownElement,