[Refactor] Pattern matching

[yannham]

This PR is preliminary work for the introduction of elimination form for ADTs. It is just a pure refactoring, which shouldn't incur any user-facing change.

This refactoring was motivated by the fact that the existing structure of the codebase used names that weren't very consistent, and relied heavily on the assumption that the only possible patterns are record patterns, which would make the addition of new patterns (ADTs, but not limited to them - constants patterns as well for e.g. strings, array patterns, regular expressions, etc.) impossible.

Content

• renaming several symbols for better consistency and generality. In particular, destructuring is now the submodule term::pattern (and same for other destructuring submodules, which are now named pattern), and the strange distinction between matches and destructuring is ditched: everything is a pattern.
• restructuring of the representation of a pattern. In particular, this PR introduces a structure that better mimics the actual ADT of a pattern, while the previous one mangled nodes together
• better handling of aliased patterns: make them an optional field instead of a separate variants, which streamline their handling in several part of the code base
• add span information to every subpattern
• factor out operations that apply to several type of patterns to proper traits, instead of declining free-standing function like do_stuff_record_pattern, do_stuff_field_pattern, etc.
• simplify the implementation of the typechecking of patterns. The previous implementation was building the type of a pattern in a first step, which is always expected to be a record type, and in a second time would extract from this type the type of the bindings brought into scope by the pattern. This extraction was a bit complicated (building a hashmap representation of the row type), and a bit unnecessary. The current implementation builds both the type of the whole pattern and the type of each binding in a single pass, which makes the implementation easier, but also doesn't have to assume that the type of the pattern will be nested record types, which is a prerequisite for extending patterns in the future.
• avoid illegal state with respect to the tail of the pattern (previously open = false, rest = Some("captured_var")
• simplify LetPattern and FunPattern to not take an additional top-level alias as an argument, and simply store this data inside the pattern itself

Review

Unfortunately, the git diff doesn't seem to understand that destructuring.rs was renamed to term/pattern.rs (and similarly for typecheck::destructuring -> typecheck::pattern, nickel_lang_lsp::destructuring -> nickel_lang_lsp::pattern). That being said, the changes are quite heavy, so maybe it's not a bad idea to just review as new code (but take a look at the deleted file to have an idea of what was the previous state).