Replaced std::exit() with return Carbon::ErrorOr for expected errors like invalid syntax (#1120)

* Replaced std::exit() with return llvm::Expected/llvm::Error<T> for expected errors like invalid syntax.

* Use llvm::formatv() for formatting lexer error messages.
x

* Addresed merge errors.

* Fixed impl scope.

* Made ErrorBuilder::operator<< nodiscard, to catch code forgetting 'return' in 'return FATAL_COMPILATION_ERROR()'.

* FatalComplationError() -> ParseAndLexContext::RecordLexerError().
Other usages of ERROR_TOKEN in lexer.lpp were actually supposed to be END_OF_FILE.

* Update executable_semantics/syntax/parse_and_lex_context.h

Co-authored-by: Jon Meow <jperkins@google.com>

* Code review fixes.

* Update executable_semantics/syntax/parser.ypp

Co-authored-by: Jon Meow <jperkins@google.com>

* More code review fixes.

* Update executable_semantics/interpreter/type_checker.h

Co-authored-by: Jon Meow <jperkins@google.com>

* Yet more code review fixes...

* Update executable_semantics/syntax/lexer.lpp

Co-authored-by: Jon Meow <jperkins@google.com>

* code review comments

* Update executable_semantics/interpreter/interpreter.cpp

Co-authored-by: Geoff Romer <gromer@google.com>

* Apply suggestions from code review

Co-authored-by: Jon Meow <jperkins@google.com>

* Update executable_semantics/syntax/lexer.lpp

Co-authored-by: Jon Meow <jperkins@google.com>

* code review

* code review

* Apply suggestions from code review

Co-authored-by: Jon Meow <jperkins@google.com>

* formatted code

* review comments

* Switched to the new ErrorOr<V> error implementation

* code review comments

* fixed comment

* restored ostream.h as #976 makes the change unnecesary

* review comments

Co-authored-by: Jon Meow <jperkins@google.com>
Co-authored-by: Geoff Romer <gromer@google.com>

executable_semantics/interpreter/action_stack.h

@@ -49,7 +49,7 @@ class ActionStack {
   // Returns the value bound to `value_node`. If `value_node` is a local
   // variable, this will be an LValue.
   auto ValueOfNode(ValueNodeView value_node, SourceLocation source_loc) const
-      -> Nonnull<const Value*>;
+      -> ErrorOr<Nonnull<const Value*>>;
 
   // Merges `scope` into the innermost scope currently on the stack.
   void MergeScope(RuntimeScope scope);
@@ -70,40 +70,42 @@ class ActionStack {
   // invoke exactly one transition method, as the very last operation. This is a
   // matter of safety as well as convention: most transition methods modify the
   // state of the current action, and some of them destroy it. To help enforce
-  // this requirement, we have a convention of calling these methods as part of
-  // return statements, e.g. `return todo_.FinishAction()`, even though they
-  // return void.
+  // this requirement, we have a convention of making these methods return an
+  // ErrorOr<Success> even when a method can't actually fail, and calling the
+  // methods as part of return statements, e.g. `return todo_.FinishAction()`.
 
   // Finishes execution of the current Action. If `result` is specified, it
   // represents the result of that Action.
-  void FinishAction();
-  void FinishAction(Nonnull<const Value*> result);
+  auto FinishAction() -> ErrorOr<Success>;
+  auto FinishAction(Nonnull<const Value*> result) -> ErrorOr<Success>;
 
   // Advances the current action one step, and push `child` onto the stack.
   // If `scope` is specified, `child` will be executed in that scope.
-  void Spawn(std::unique_ptr<Action> child);
-  void Spawn(std::unique_ptr<Action> child, RuntimeScope scope);
+  auto Spawn(std::unique_ptr<Action> child) -> ErrorOr<Success>;
+  auto Spawn(std::unique_ptr<Action> child, RuntimeScope scope)
+      -> ErrorOr<Success>;
 
   // Advances the current action one step.
-  void RunAgain();
+  auto RunAgain() -> ErrorOr<Success>;
 
   // Unwinds Actions from the stack until the StatementAction associated with
   // `ast_node` is at the top of the stack.
-  void UnwindTo(Nonnull<const Statement*> ast_node);
+  auto UnwindTo(Nonnull<const Statement*> ast_node) -> ErrorOr<Success>;
 
   // Unwinds Actions from the stack until the StatementAction associated with
   // `ast_node` has been removed from the stack. If `result` is specified,
   // it represents the result of that Action (StatementActions normally cannot
   // produce results, but the body of a function can).
-  void UnwindPast(Nonnull<const Statement*> ast_node);
-  void UnwindPast(Nonnull<const Statement*> ast_node,
-                  Nonnull<const Value*> result);
+  auto UnwindPast(Nonnull<const Statement*> ast_node) -> ErrorOr<Success>;
+  auto UnwindPast(Nonnull<const Statement*> ast_node,
+                  Nonnull<const Value*> result) -> ErrorOr<Success>;
 
   // Resumes execution of a suspended continuation.
-  void Resume(Nonnull<const ContinuationValue*> continuation);
+  auto Resume(Nonnull<const ContinuationValue*> continuation)
+      -> ErrorOr<Success>;
 
   // Suspends execution of the currently-executing continuation.
-  void Suspend();
+  auto Suspend() -> ErrorOr<Success>;
 
  private:
   // Pop any ScopeActions from the top of the stack, propagating results as