Implement non-ascii variables in Java and Rust

[flyingsilverfin]

What is the goal of this PR?

We update to TypeQL with Unicode support in both value and concept variables. This makes the following valid TypeQL:

match $人 isa person, has name "Liu"; get  $人;

match $אדם isa person, has name "Solomon"; get $אדם;

We now require all Labels and Variables are valid unicode identifiers not starting with _.

This change is fully backwards compatible. We also validate that Type Labels and Variables created using the TypeQL language builders in both Rust and Java are conforming to our Unicode specification.

What are the changes implemented in this PR?

• Refactor variable names to allow the same range of characters as Labels - which is unicode identifier excluding a leading _
• Add language builder validation for the strings provided to Labels or Variable names
• Update typedb-behaviour

[typedb-bot]

PR Review Checklist

Do not edit the content of this comment. The PR reviewer should simply update this comment by ticking each review item below, as they get completed.

---

Trivial Change

• This change is trivial and does not require a code or architecture review.

Code

• Packages, classes, and methods have a single domain of responsibility.
• Packages, classes, and methods are grouped into cohesive and consistent domain model.
• The code is canonical and the minimum required to achieve the goal.
• Modules, libraries, and APIs are easy to use, robust (foolproof and not errorprone), and tested.
• Logic and naming has clear narrative that communicates the accurate intent and responsibility of each module (e.g. method, class, etc.).
• The code is algorithmically efficient and scalable for the whole application.

Architecture

• Any required refactoring is completed, and the architecture does not introduce technical debt incidentally.
• Any required build and release automations are updated and/or implemented.
• Any new components follows a consistent style with respect to the pre-existing codebase.
• The architecture intuitively reflects the application domain, and is easy to understand.
• The architecture has a well-defined hierarchy of encapsulated components.
• The architecture is extensible and scalable.