Better errors when using unknown data-type constructor.

## Before

  ```
    × Checking
    ╰─▶ Unknown variable

            Finite

      ╭─[../stdlib/validators/tmp.ak:10:1]
   10 │   let now = when context.transaction.validity_range.lower_bound.bound_type is {
   11 │     Finite { t } -> t
      ·     ────────────
   12 │     NegativeInfinity -> 0
      ╰────
  ```

  ## After

  ```
    × Type-checking
    ╰─▶ Unknown data-type constructor 'Finite'

      ╭─[../stdlib/validators/tmp.ak:10:1]
   10 │   let now = when context.transaction.validity_range.lower_bound.bound_type is {
   11 │     Finite { t } -> t
      ·     ────────────
   12 │     NegativeInfinity -> 0
      ╰────
    help: Did you forget to import it?

          Data-type constructors are not automatically imported, even if their type is
          imported. So, if a module `aiken/pet` defines the following type:

           ┍━ aiken/pet.ak ━━━━━━━━
           │ pub type Pet {
           │   Cat
           │   Dog
           │ }

          You must import its constructors explicitly to use them, or prefix them
          with the module's name.

           ┍━ foo.ak ━━━━━━━━
           │ use aiken/pet.{Pet, Dog}
           │
           │ fn foo(pet : Pet) {
           │   when pet is {
           │     pet.Cat -> // ...
           │     Dog -> // ...
           │   }
           │ }
  ```

crates/aiken-lang/src/tipo/environment.rs

@@ -315,10 +315,20 @@ impl<'a> Environment<'a> {
         location: Span,
     ) -> Result<&ValueConstructor, Error> {
         match module {
-            None => self.scope.get(name).ok_or_else(|| Error::UnknownVariable {
+            None => self.scope.get(name).ok_or_else(|| {
-                name: name.to_string(),
+                if name.chars().into_iter().next().unwrap().is_uppercase() {
-                variables: self.local_value_names(),
+                    Error::UnknownTypeConstructor {
-                location,
+                        name: name.to_string(),
+                        variables: self.local_value_names(),
+                        location,
+                    }
+                } else {
+                    Error::UnknownVariable {
+                        name: name.to_string(),
+                        variables: self.local_value_names(),
+                        location,
+                    }
+                }
             }),
 
             Some(m) => {

crates/aiken-lang/src/tipo/error.rs

@@ -225,6 +225,40 @@ pub enum Error {
         variables: Vec<String>,
     },
 
+    #[error("Unknown data-type constructor '{name}'\n")]
+    #[diagnostic(help(
+        r#"Did you forget to import it?
+
+Data-type constructors are not automatically imported, even if their type is
+imported. So, if a module `aiken/pet` defines the following type:
+
+ ┍━ aiken/pet.ak ━━━━━━━━
+ │ pub type Pet {{
+ │   Cat
+ │   Dog
+ │ }}
+
+You must import its constructors explicitly to use them, or prefix them
+with the module's name.
+
+ ┍━ foo.ak ━━━━━━━━
+ │ use aiken/pet.{{Pet, Dog}}
+ │
+ │ fn foo(pet : Pet) {{
+ │   when pet is {{
+ │     pet.Cat -> // ...
+ │     Dog -> // ...
+ │   }}
+ │ }}
+"#
+    ))]
+    UnknownTypeConstructor {
+        #[label]
+        location: Span,
+        name: String,
+        variables: Vec<String>,
+    },
+
     #[error("Unnecessary spread operator\n")]
     UnnecessarySpreadOperator {
         #[label]

crates/aiken-project/src/error.rs

@@ -74,7 +74,7 @@ pub enum Error {
         error: Box<ParseError>,
     },
 
-    #[error("Checking")]
+    #[error("Type-checking")]
     Type {
         path: PathBuf,
         src: String,