…It only refactors the interpreter to be able to change the semantics or add additional functionality to it.

At first, I was trying to do a monad-style interpreter, but TypeScript does not have do-notation, which can quickly produce unreadable code because of the bind functions.
Although, there are some suggestions over the internet on how to emulate do-notation using generators, it looks ad-hoc, hacky, and unnatural.
So, I decided to take the idea of monad and adapt it into an imperative flavor.
The idea is to define the semantics of an interpreter as an abstract class parametric over two generic types: "V" (the type of expressions' results) and
"S" (the type of statements' results).
At the moment, module level declarations do not have an associated generic type, but it will probably be added.

Specific semantics can be represented by implementing the abstract class.
For example, to create an interpreter with the standard semantics, just write:

const interpreter = new Interpreter(new StandardSemantics(ctx));

If we want to change the behavior, for example, by collecting special values when statements execute, just pass another semantics:

const interpreter = new Interpreter(new YourCustomSemantics(ctx));

This is a first version of the "monadish" interpreter. As such, it probably will suffer changes as more semantics are added since
they will probably force changes to the interface in the abstract class.

…itionals.

…hod.

It also supports variable tracing in structs.

… did not show it. This was due to partial evaluator making use of dummySrcInfo.

- forgot to change initialSctx in foreach statement to foreachSctx

Added negative tests.

Partial commit (does not compile).

…elated to variable tracing to a test folder inside interpreters folder (since constant propagation analyzer is an instance of interpreter).

However, one test case is still failing, but it does not have to do with the analyzer. Will merge with main to see if it solves the issue.

Added lattice for values: this simplified join operations.