The beginning of a language specification test category dedicated to
hooks is added. At the moment, only the exception-effect-related
behaviour is covered.

The procedure symbol is also marked with the `sfNeverRaises` flag, so
that defects are prevented from escaping at run-time (they're not
tracked at compile-time).

A new report is added: `rsemHooksCannotRaise`.

Lifting/synthesizing hooks no longer needs to track whether an
exception is possible.

They're guaranteed to not require exception propagation, so a normal
`mnkCall` can always be used.

The comment detailing the now-resolved problem with hooks that raise is
also removed.

If a procedure is flagged with `sfNeverRaises`, the body is wrapped in
a catch-all exception handler, where the new `nimUnhandledException`
runtime procedure is invoked from the handler. If the handler is not
actually used, `cgirgen`'s unreachable code elimination automatically
eliminates it again.

Implementing this in `mirgen` ensures consistent behaviour across all
backends.

For the VM, it's not as simple as for the other two, so the
implementation is still missing.

The trace hooks were considered to be able to raise exceptions and have
effects, but this is no longer the case, so the pointer can be safely
cast to procedural values without.

The callback is only used internally, so this does not constitute a
breaking change of the `Task` API.

Three individual tests need to be adjusted to the language change:
* `tnew` and `gctest use `debugEcho` instead of `write` (the former
  has no effects)
* `tarcmisc` has to cast away the raise effects of `Stream.close` for
  now

Hooks not being considered as potentially raising is visible in the
pretty-printed MIR output.

Reporting of unhandled exceptions doesn't include a trailing ':' in the
displayed message if there's no exception message. A message is now set
on the raised defect, which, besides resulting in consistent output,
also helps makes sure that the correct defect is reported.

The procedure is implemented as a syscall (`vmops`), which raises the
existing `vmEvtUnhandledException` VM event, thus terminating the VM
right away.

Since syscall implementations are currently unable to create a stack-
trace, no stack-trace is passed along, which
`compilerbridge.buildError` now accounts for (by creating the stack-
trace itself). This is somewhat hack-y.

While not possible directly with JavaScript, node.js provides
`process.exit`, which allows terminating in case of an unhandled
exception.