deps: remove thiserror, impl Error manually

Before:

```
$ cargo tree --edges build,normal
bcs v0.1.6 (/home/phlip9/dev/bcs)
├── serde v1.0.228
│   ├── serde_core v1.0.228
│   └── serde_derive v1.0.228 (proc-macro)
│       ├── proc-macro2 v1.0.106
│       │   └── unicode-ident v1.0.24
│       ├── quote v1.0.45
│       │   └── proc-macro2 v1.0.106 (*)
│       └── syn v2.0.117
│           ├── proc-macro2 v1.0.106 (*)
│           ├── quote v1.0.45 (*)
│           └── unicode-ident v1.0.24
└── thiserror v1.0.69
    └── thiserror-impl v1.0.69 (proc-macro)
        ├── proc-macro2 v1.0.106 (*)
        ├── quote v1.0.45 (*)
        └── syn v2.0.117 (*)

$ rm -rf /tmp/cargo-target && taskset -c 3 cargo build --target-dir /tmp/cargo-target --lib
    Finished dev [unoptimized + debuginfo] target(s) in 7.89s
```

After:

```
$ cargo tree --edges build,normal
    Updating crates.io index
bcs v0.1.6 (/home/phlip9/dev/bcs)
└── serde_core v1.0.228

$ rm -rf /tmp/cargo-target && taskset -c 3 cargo build --target-dir /tmp/cargo-target --lib
   Compiling serde_core v1.0.228
   Compiling bcs v0.1.6 (/home/phlip9/dev/bcs)
    Finished dev [unoptimized + debuginfo] target(s) in 1.38s
```

Author: phlip9

Cargo.toml

@@ -8,7 +8,6 @@ license = "Apache-2.0"
 edition = "2018"
 
 [dependencies]
-thiserror = "1.0.37"
 serde_core = { version = "1", default-features = false }
 
 [dev-dependencies]

src/error.rs

@@ -3,46 +3,62 @@
 
 use serde_core::{de, ser};
 use std::{fmt, io::ErrorKind};
-use thiserror::Error;
 
 pub type Result<T, E = Error> = std::result::Result<T, E>;
 
-#[derive(Clone, Debug, Error, Eq, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum Error {
-    #[error("unexpected end of input")]
     Eof,
-    #[error("I/O error: {0}")]
     Io(String),
-    #[error("exceeded max sequence length: {0}")]
     ExceededMaxLen(usize),
-    #[error("exceeded max container depth while entering: {0}")]
     ExceededContainerDepthLimit(&'static str),
-    #[error("expected boolean")]
     ExpectedBoolean,
-    #[error("expected map key")]
     ExpectedMapKey,
-    #[error("expected map value")]
     ExpectedMapValue,
-    #[error("keys of serialized maps must be unique and in increasing order")]
     NonCanonicalMap,
-    #[error("expected option type")]
     ExpectedOption,
-    #[error("{0}")]
     Custom(String),
-    #[error("sequence missing length")]
     MissingLen,
-    #[error("not supported: {0}")]
     NotSupported(&'static str),
-    #[error("remaining input")]
     RemainingInput,
-    #[error("malformed utf8")]
     Utf8,
-    #[error("ULEB128 encoding was not minimal in size")]
     NonCanonicalUleb128Encoding,
-    #[error("ULEB128-encoded integer did not fit in the target size")]
     IntegerOverflowDuringUleb128Decoding,
 }
 
+impl std::error::Error for Error {}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Eof => f.write_str("unexpected end of input"),
+            Self::Io(err) => write!(f, "I/O error: {err}"),
+            Self::ExceededMaxLen(len) => write!(f, "exceeded max sequence length: {len}"),
+            Self::ExceededContainerDepthLimit(ty) => {
+                write!(f, "exceeded max container depth while entering: {ty}")
+            }
+            Self::ExpectedBoolean => f.write_str("expected boolean"),
+            Self::ExpectedMapKey => f.write_str("expected map key"),
+            Self::ExpectedMapValue => f.write_str("expected map value"),
+            Self::NonCanonicalMap => {
+                f.write_str("keys of serialized maps must be unique and in increasing order")
+            }
+            Self::ExpectedOption => f.write_str("expected option type"),
+            Self::Custom(msg) => f.write_str(msg),
+            Self::MissingLen => f.write_str("sequence missing length"),
+            Self::NotSupported(msg) => write!(f, "not supported: {msg}"),
+            Self::RemainingInput => f.write_str("remaining input"),
+            Self::Utf8 => f.write_str("malformed utf8"),
+            Self::NonCanonicalUleb128Encoding => {
+                f.write_str("ULEB128 encoding was not minimal in size")
+            }
+            Self::IntegerOverflowDuringUleb128Decoding => {
+                f.write_str("ULEB128-encoded integer did not fit in the target size")
+            }
+        }
+    }
+}
+
 impl From<std::io::Error> for Error {
     fn from(err: std::io::Error) -> Self {
         if err.kind() == ErrorKind::UnexpectedEof {