Improve Exceptions support

[quasilyte]

Compiler memory consumption comparison:

old:

  memory.rss: 13711200256
  memory.rss_peak: 13970407424

  compilation.transpilation_time: 47.7062
  compilation.object_out_size: 39337976

new (with exceptions tracking + @kphp-throws vector inside func info):

  memory.rss: 13838069760 (+1%)
  memory.rss_peak: 14024077312 (+0.6%)

  compilation.transpilation_time: 46.0325
  compilation.object_out_size: 40028272

Notes:

• Added support for multiple catch clauses per try block
• Added \Throwable interface; \Exception now implements \Throwable
• Added \Error class that implements \Throwable + SPL Exception classes
• Old KPHP code will generate the same C++ code for the try/catch blocks
• All code generated code diff is new Exception(...) => __exception_set_location(new Exception(...), __FILE__, __LINE__) and an instance cast of exception var if it's not Throwable
• Code that catches all possible exceptions does not propagate any (exceptions are tracked)
• This PR does not implement finally on purpose

--

Enabled exceptions inheritance.

• updated CFG and other passes so they handle the program flow correctly

• codegen generates 2 new cases for the try/catch ops.
  If exception class has derived classes, is_a() is used;
  If exception class has no derived classes, hash comparison is used;
  When the code catches \Exception class, same codegen is used.

Exceptions in CFG propagate like this: if try block catches
all exceptions, we consider that nothing propagates.
Otherwise, we consider all exceptions that can be created inside try block do propagate.
We may do exceptions tracking here as well, but it doesn't affect
the code generation right now.

--

Added PreprocessException pass.

Add __FILE__ and __LINE__ arguments to the Exception-derived
construction call in the PreprocessException pass instead of
doing it in the lexer.

The problem with lexer is that it tries to know about the
Exception class and adds these arguments too early.

If Exception class can be extended, then we don't know
whether a new T() expression constructs an exception class.
The PreprocessException has class data info, so it can
perform this operation with more accuracy.

We also change the Exception class constructor signature so
it's compatible with the PHP version. It doesn't accept the
file and line arguments now; to set these fields, a new builtin function
is added that is inserted by the compiler.

This transformation can be described as:

    new T(args...)
    =>
    __exception_set_location(new T(args...), __FILE__, __LINE__)

Where __exception_set_location() call returns the modified exception.

This patch does not add missing Exception-related features,
but it makes it's needed to make the work in that direction possible.

[quasilyte]

The code may be rough in some places, but it's ready for the review.
I tested the compiler on vkcom, the diff is predictable (__exception_set_location).

[quasilyte]

php-src tests are failing due to the fact that KPHP now resolves the classes used in catch.
Before that, it was ignoring them and implied \Exception.

Right now we're missing TypeError exception class (and maybe some other classes, I need to reproduce this thing locally).

In stage = [Inject locations into the created exceptions]:
  [file = php-src/ext/standard/tests/strings/strrpos_offset.phpt]
  [function = src_strrpos_offset_phpt56dbca052236ad80:9]
  [line = 9]
//   9:    echo $e->getMessage(), "\n ";
Can't find class: TypeError

[quasilyte]

Some extra generated code diff is expected now: since CurException is a Throwable now, not Exception, when there is a catch on \Exception we need to do an instance_cast there.

[quasilyte]

Tested exception tracking with KPHP_VERBOSITY=2.
Same functions.total_throwing value for vkcom.

Also compared the passes execution time.
The most affected passes are CalcActualCallsEdgesPass and FilterOnlyActuallyUsedFunctionsF. Their performance is comparable for our current code. It will be slower for the code that throws different kinds of exceptions.

[quasilyte]

Ready for review.