Use miette for reporting errors

This gives us errors with annotated context like this:

```
Error:
  × type error: Unknown variable 'x'
    ╭─[isle_examples/let.isle:24:1]
 24 │   (Lower (B.B z))
 25 │   (A.Add x y))
    ·          ┬
    ·          ╰── Unknown variable 'x'
    ╰────
```

cranelift/isle/islec/Cargo.toml

@@ -10,3 +10,4 @@ log = "0.4"
 isle = { version = "*", path = "../isle/" }
 env_logger = { version = "0.8", default-features = false }
 clap = "2.33"
+miette = { version = "3.0.0", features = ["fancy"] }

cranelift/isle/islec/src/main.rs

@@ -1,10 +1,20 @@
 use clap::{App, Arg};
+use isle::{compile, lexer, parser};
+use miette::{IntoDiagnostic, Result};
 
-use isle::{error, lexer, parser, compile};
-
-fn main() -> Result<(), error::Error> {
+fn main() -> Result<()> {
     let _ = env_logger::try_init();
 
+    let _ = miette::set_hook(Box::new(|_| {
+        Box::new(
+            miette::MietteHandlerOpts::new()
+                // `miette` mistakenly uses braille-optimized output for emacs's
+                // `M-x shell`.
+                .force_graphical(true)
+                .build(),
+        )
+    }));
+
     let matches = App::new("isle")
         .version(env!("CARGO_PKG_VERSION"))
         .author("Chris Fallin <chris@cfallin.org>")
@@ -37,31 +47,14 @@ fn main() -> Result<(), error::Error> {
 
     let lexer = lexer::Lexer::from_files(input_files)?;
     let mut parser = parser::Parser::new(lexer);
-    let defs = match parser.parse_defs() {
-        Ok(defs) => defs,
-        Err(error) => {
-            eprintln!("{}", error);
-            eprintln!("Failed to parse input.");
-            std::process::exit(1);
-        }
-    };
-    let code = match compile::compile(&defs) {
-        Ok(code) => code,
-        Err(errors) => {
-            for error in errors {
-                eprintln!("{}", error);
-            }
-            eprintln!("Failed to compile.");
-            std::process::exit(1);
-        }
-    };
+    let defs = parser.parse_defs()?;
+    let code = compile::compile(&defs)?;
 
     {
         use std::io::Write;
-        let mut f = std::fs::File::create(output_file)?;
-        writeln!(&mut f, "{}", code)?;
+        let mut f = std::fs::File::create(output_file).into_diagnostic()?;
+        writeln!(&mut f, "{}", code).into_diagnostic()?;
     }
 
     Ok(())
 }
-