Define ID types as specializations, rather than newtypes.

This is based heavily on the work done for normalized strings, in `crate::normalize`. The key realization in that module is that the logic distinguishing one kind of thing (normalized strings in that case, IDs, in this case) can be packaged up as a type token, and that doing so may reduce the overall complexity. This implementation for ID also borrows heavily from the implementation for normalized strings.

It's less flexible: an ID implemented this way can't expose _less_ of `crate::id::ID`'s interface, whereas newtype wrappers can, for example. However, our code doesn't use that flexiblity on purpose anywhere and we're relatively unlikely to change that. In return, the individual ID types require substantially less code - they do not, for example, need to re-implement `Display` for themselves.

I very nearly made the trait `Prefix`:

```rust
pub trait Prefix {
    const PREFIX: &str;
}
```

however, I think having an effectively-constant method is less surprising overall.

1 files changed, 6 insertions, 20 deletions

diff --git a/src/invite/id.rs b/src/invite/id.rs
index bd53f1f..c37f3ac 100644
--- a/src/invite/id.rs
+++ b/src/invite/id.rs
@@ -1,24 +1,10 @@
-use crate::id::Id as BaseId;
+pub type Id = crate::id::Id<Invitation>;
 
-// Stable identifier for an invite Prefixed with `I`.
-#[derive(Clone, Debug, Eq, PartialEq, sqlx::Type, serde::Deserialize, serde::Serialize)]
-#[sqlx(transparent)]
-pub struct Id(BaseId);
+#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct Invitation;
 
-impl From<BaseId> for Id {
-    fn from(id: BaseId) -> Self {
-        Self(id)
-    }
-}
-
-impl Id {
-    pub fn generate() -> Self {
-        BaseId::generate("I")
-    }
-}
-
-impl std::fmt::Display for Id {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        self.0.fmt(f)
+impl crate::id::Prefix for Invitation {
+    fn prefix(&self) -> &'static str {
+        "I"
     }
 }