A qualified destructor-id in an explicit destructor call via `->`/`.`, e.g.
`p->std::vector<int>::~vector()` or `p->A::~A()`, produced an ERROR node.
`qualified_identifier` already accepts a trailing `destructor_name`, but
`qualified_field_identifier` (the member-access path) did not; mirror it there.

The destructor-id in an explicit destructor call may name a class template
specialization, e.g. `p->~vector<int>()` or `p->~shared_ptr<const T>()`.
`destructor_name` only allowed `~ identifier`, so any template-id after `~`
produced an ERROR node. Allow an optional `template_argument_list` and add a
GLR conflict for `destructor_name` to resolve the `<` (template-args vs
less-than) ambiguity. A plain `~Name` is unchanged.

- allow module related statements to appear in preprocessor blocks
- export declarations can now appear anywhere other declarations can

Introduces support for `template for ( init; for-range-decl : expansion-init )`
which is a compile-time way to expand (iterate over):
  - expansion expressions
  - anything destructurable via structured bindings
  - ranges with compile time size

It was sufficient to simply re-use the existing rule for
_for_range_loop_body for the part inside the parentheses, but add the
required sequence of `template` followed by `for`

Related to reflection, annotations use the same syntax as attributes,
but begin with an `=` and support any constant expression. Annotations
and Attributes can't be mixed within [[ ... ]].

This adds support for all the language changes introduced in P2996 which
was recently voted into the upcoming c++26 standard.

This includes:
- reflection expressions: the reflect operator (^^) followed by
  expressions, type descriptors, or the global namespace (::)
- splice specifiers/expressions: [: expression :], which can appear as a
  type, expression, alias descriptor, and more.
- consteval blocks: similar to static_asserts but have been introduced
  specifically to allow constant evaluation side effects to occur at
  specific places in code

Closes #252.

Fixes #301

P1102R2 relaxed lambda syntax so that () (empty parameter list) is
optional in more cases.

Addresses #224 and properly parses all C++ numbers.

This change allows operators (not just fields/member functions) as dependent
template expressions.

```cpp
auto x = y.template operator()<int>();
```

This syntax is used e.g. to call C++20 lambda expressions with a template head
where the template arguments are not function arguments and therefore cannot be
deduced.

```cpp
[]<typename> () {}.template operator()<int>();
```

This change allows commas inside subscripts.

```cpp
auto x = a[1, 2, 3];
```

From C++23, array subscripts work like arguments to `operator[]` as an n-ary
function.

Before C++23, `operator[]` must be a unary function, but before C++20, it's
possible to use the comma operator inside subscript expressions - and this is
done in libraries that use expression templates to achieve multidimensional
array syntax.

Use of the comma operator in subscript expressions was deprecated in C++20 to
make way for the C++23 change to n-ary `operator[]`.

breaking change: namespace_definition_name has been renamed to
nested_namespace_specifier and the nesting has been reversed to match
the way normal scope resolution works elsewhere.

identifiers that are part of a namespace_definition are now
namespace_identifier, which matches the identifier node type used in
scope resolution for qualified types.

namespace alias definitions use the new nested_namespace_specifier so
all identifiers are namespace_identifier nodes.

support for top-level "inline" namespace declarations (which are valid
if they are nested in another namespace body).

Fixes #193

breaking changes:
- access_specifier is now a named node in base class clauses
- virtual_function_specifier node has been renamed to virtual

Fixes #184

Include rawstring delimiters in the tree, use for injections

In raw-strings, the delimiter can be used to indicate embedded language:

   R"css( body { background: red; } )css"

This patch adds the delimiter (if present) and raw-string content as
children of the raw_string_literal.

These can be used to parse the content with an injected grammar.

Fixes https://github.com/tree-sitter/tree-sitter-cpp/issues/159