[fix] stdlib: List.split_between was missing a case

If [l] has between [min] and [max], we would return {none}
[feature] xml_parser: more patterns for attributes

Each xml tag has an attribute list.
An attribute is a triple (namespace, name, value), written namespace:name = value.
You can now match an (unordered) attribute list with a (ordered) list of attribute patterns.
An attribute pattern is either:
1. a normal attribute pattern namespace_pattern : name_pattern = value_pattern
namespace_pattern, name_pattern, and value_pattern are like newly introduced tag name patterns, i.e., an optional binding followed by _ (any) or a disjunction (separator |) of
some_name or "some string with {opa insertions}" or {an opa expression representing a parser}, or (a string parser)
Unlike tag name patterns, binding are made with := instead of =
= value_pattern is optional, as well as namespace_pattern :
If name_pattern is a simple name, the value is bound to this name (like it was done previously)
2. a prefixed attribute pattern
If not prefixed, a matched attribute pattern removes the attribute from the remaining attribute list
If prefixed with &, the pattern will not remove the matched attribute
If prefixed with !, !pattern will match only if pattern would not match (no binding is allowed)
3. a suffixed attribute pattern: a pattern followed by a suffix (?, +, *, {x}, or {x,y})
No binding is accepted except at the beginning to bind the whole list (or the option for ?)
4. any attribute: .

Complex examples:
We want to match an element <a ... /> with the following attributes:
- no attributes: <a !. />
- exactly one attribute: <a . !. />
- only attributes from namespace ns: <a "{ns}":_* !. />
- two attributes x and y having the same value: <a x y="{x}" />
- an attribute x, and bind y to the other attributes: <a x y:=.* />
- an attribute x, and bind y to all the attributes (x included): <a &x y:=.* />
- an attribute b starting with a and having a c in the third position: <a &b=("a" .*) &b=(.."c".*) />

/!\ This will break any weird xml_parser such as
<t a={x} a={y}>
because now, matched attributes are eaten

/!\ Greedy, no backtracking
<a x:=_ "{x}" /> can match <a b="c" c="d" /> only if you are lucky.
The order of the attributes is not guaranted, hence
x:=_ can match either b="c" (binding x to "b") or c="d" (binding x to "c")
{x} can only match the other attribute, since the first one has been eaten