[golang/go] proposal: x/net/html: add a ParseOption to control open element stack limit

### ROOT CAUSE The fixed open element stack limit of 128 in the x/net/html package is too low for some valid HTML documents, causing parse errors. This limit was introduced to prevent quadratic parsing behavior, but it is not configurable. Some users have encountered this limit when processing valid HTML documents, indicating that the fixed limit is insufficient for certain use cases. ### CODE FIX We propose to make the open element stack limit configurable via a new ParseOption called `OpenElementLimit`. The default limit is 128 (the current fixed limit). The change involves: 1. Adding a new functional option type `ParseOption` (if not already defined) and the option function `OpenElementLimit`. 2. Modifying the `Parse` function to accept a variable number of `ParseOptions`. 3. Adding a new field to the `Parser` struct to store the limit. 4. In the parser code, when about to push an open element, check if the current stack depth exceeds the limit (if the limit is non-zero) and return an error if so. Here is the code change: ```go // Add this at the top if not already present (if we are using the functional option pattern, we need to define the interface): type ParseOption interface { apply(*Parser) } // Then, in the file, define the option function: func OpenElementLimit(limit int) ParseOption { return func(p *Parser) { if limit < 0 { limit = 0 } p.openElementLimit = limit } } // Then, change the Parse function: func Parse(r io.Reader, opts ...ParseOption) (*Node, []Error) { p := &Parser{ openElementLimit: 128, // default // ... other fields } // Apply the options for _, opt := range opts { opt.apply(p) } // Then, proceed with the parsing. } // Then, in the Parser struct, add the field: type Parser struct { // ... other fields openElementLimit int // ... other fields } // Then, in the function that processes the tags (where we push open elements), add the check: if p.openElementLimit != 0 && len(p.openElements) >= p.openElementLimit { // error: too many open elements } ``` This change allows users to set the open element limit via a `ParseOption`, while maintaining the default of 128 for backward compatibility. The condition checks if the current stack depth exceeds the limit and returns an error if so.