conlang: Import items into scope with use!

grammar:
- Improve specification of `Path`
- Add `Use` and `UseTree` rules
- Add `Use` as a variant of ItemKind

cl-token:
- Add new keywords `use` and `as`

cl-ast:
- Add nodes for Use and UseTree
- Add new ItemKind for Use
- Implement traversal in Visit and Fold

cl-interpret:
- Mark ItemKind::Use with a todo

cl-parser:
- Update to match grammar

cl-typeck:
- Update to match changes in AST
- Mark UseTrees as NameCollectable and TypeResolvable, but leave as todos

compiler/cl-ast/src/ast_impl.rs

@@ -116,6 +116,7 @@ mod display {
                 ItemKind::Struct(v) => v.fmt(f),
                 ItemKind::Enum(v) => v.fmt(f),
                 ItemKind::Impl(v) => v.fmt(f),
+                ItemKind::Use(v) => v.fmt(f),
             }
         }
     }
@@ -280,6 +281,27 @@ mod display {
         }
     }
 
+    impl Display for Use {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let Self { tree } = self;
+            write!(f, "use {tree}")
+        }
+    }
+
+    impl Display for UseTree {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            match self {
+                UseTree::Tree(path, tree) => {
+                    write!(f, "{path}")?;
+                    separate(tree, ", ")(f.delimit(INLINE_BRACES))
+                }
+                UseTree::Alias(path, name) => write!(f, "{path} as {name}"),
+                UseTree::Path(path) => write!(f, "{path}"),
+                UseTree::Glob => write!(f, "*"),
+            }
+        }
+    }
+
     impl Display for Ty {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             self.kind.fmt(f)
@@ -665,6 +687,7 @@ mod convert {
             Struct => ItemKind::Struct,
             Enum => ItemKind::Enum,
             Impl => ItemKind::Impl,
+            Use => ItemKind::Use,
         }
         impl From for StructKind {
             Vec<Ty> => StructKind::Tuple,