Document the exception hierarchy, and make a refusal name what it choked on (#746 item 11)

[Rafael-SOWNet]

Roadmap #746, item 11. One of that
issue's three founding complaints is that failure here is uninformative: "I could not settle
this" tells a caller nothing about what to try instead and a contributor nothing about what to
build. An exception that names the sub-expression it choked on is the cheapest instance of the
principle.

What was measured

On master at v2.3.0, over Sources/AngouriMath/**/*.cs:

	before	after
throw new sites (excluding 9 that are inside XML doc <code> samples, not code)	197	197
whose message is a compile-time constant	106	73
whose message carries a runtime value	31	67
whose message names the offending sub-expression	8	25
exception types under AngouriMathBaseException	25	25
of those, documented in Docs/Usage/Exceptions.md	1	25

Docs/Usage/Exceptions.md

Rewritten from three lines to the whole hierarchy, derived by reading
Core/Exceptions/** and every throw site rather than from memory. Each type gets what it means,
when a caller can expect it, and where it is raised from. The organising split is the one a caller
actually acts on:

• MathSException — the input was wrong. Catch it and show the message.
• NotSufficientlySupportedException — the library has no procedure for the question. A feature
  request, and catchable.
• AngouriBugException — a defect. Not a catch target; catching it turns a reproducible bug
  into a silent wrong answer.

It also states the overlaps rather than leaving them to be discovered:
FunctionArgumentCountException is the arity complaint about a call written in a string and
WrongNumberOfArgumentsException the one about a call made through the API — only the first is
a ParseException, so they are not interchangeable; BadMatrixShapeException exists only for
concatenation and InvalidMatrixOperationException is the type any new shape check should use.
And it documents MathS.Diagnostic.DiagnosticCatchException, the one exception the library throws
that is deliberately outside the hierarchy, so that a caller's catch (AngouriMathBaseException)
cannot swallow their own debugging aid.

One gap the reading found, recorded and not fixed here. UnrecognizedDomainException is thrown
by nothing. The place that would raise it — Entity.Set.SpecialSet.ToDomain(string), reachable
through the public SpecialSet.Create(string) — answers an unknown domain name with
AngouriBugException, which asks the caller to report their own typo as a library defect. That is
the wrong answer to a wrong string, but correcting it changes which exception a caller sees, so it
wants a pull request of its own rather than this one.

The messages

Where the offending expression or value was already in scope, it is now in the message. The
user-reachable paths first:

• parsing — ANTLR's diagnostic is a line and a column and nothing else, which names no input
  once the string has travelled through a caller's own layers. The source is now appended (not
  prepended: FromStringTest asserts on the line L:C prefix, and it is what a reader looks for
  first).
• evaluation — EvalNumerical / EvalBoolean say what the expression did evaluate to,
  instead of "Result cannot be represented as a simple number!".
• matrices — every operation that compares shapes now prints both of them, and AsScalar,
  Pow, WithElement, WithRow, WithColumn and MatrixBuilder print the shape they got.
  operator + and operator - no longer share one message that says which of them it was.
• sets — an undecidable Contains names the element and the set.
• compilation — a node with no compiled form prints itself rather than saying "Tensors cannot
  be compiled".
• truth tables — the expression and the variables it is actually over.
• plus MathS.ToBaseN's base, Rational.Create's non-finite value, the decimal precision that did
  not fit in an int32, and a handful of internal AngouriBugException asserts that now print the
  two sizes or the enum value that did not match.

Nothing was manufactured: where a site has nothing in scope to name — "No rows were provided",
"Cannot concat 0 matrix" — it was left alone.

Cost. Every interpolation is written inside the throw new expression, so it is evaluated only
when the exception is constructed and a path that does not throw pays nothing.

What was deliberately not done

• No exception type was added, removed or changed, and no site throws a different type than it
  did. That is a breaking change and this is not the PR for it.
• No BREAKING-CHANGES.md entry: message text is not an answer.
• The parse errors that live in the generated ANTLR parser (arcsinh and its neighbours,
  "Expected integer number for the third argument of derivative", the apply/lambda arity
  refusals) were left alone — they come from AngouriMath.g and changing them means regenerating
  the parser, which is its own change.

Tests asserting on message text

Checked before touching anything, by grepping every string being changed. Six tests do assert on a
message: FromStringTest (the line L:C prefix, and the exact FunctionArgumentCountException
wording), MissingFunctionNamesRefusedTest and ArcHyperbolicRefusedTest (substrings of the
parser's refusals), MatrixCompilationTest ("Matrix"), CircleTest (the whole
CannotParseInstanceException message) and CompileUnboundVariableTest (the named variable).
None of the messages they pin were moved, and all six still pass unmodified.

Measured

dotnet build Sources/AngouriMath -c Release — 0 warnings, 0 errors.

dotnet test Sources/Tests/UnitTests -c Release:

• with the message changes and before the new test file: 7533 passed / 0 failed / 14 skipped,
  identical to master's baseline.
• with the new test file: 7549 passed / 0 failed / 14 skipped (+17 new tests, of which one
  wall-clock limit test flaked under load and passes on its own).

dotnet test Sources/Tests/FSharpWrapperUnitTests -c Release — 134 passed / 0 failed.

New file: Sources/Tests/UnitTests/Core/ExceptionMessageNamesTheExpressionTest.cs, pinning the
parse-failure input, the evaluated-to form, both matrix shapes, the element and the set, the
uncompilable node, the base, the truth-table variables and the builder widths — plus a test that
the same paths still succeed when nothing is wrong.