everywhere: Add support for typed comptime generics

This is useful as C++ NTTPs are limited in what they can be, specifying
the type allows the compiler to omit the unusable ones from codegen.

Author: alimpfard

samples/generics/typed_and_untyped_const_generics.jakt

@@ -0,0 +1,17 @@
+/// Expect:
+/// - output: "typed: 10\nuntyped: 20\n"
+
+comptime id<T>(anon x: T) -> T => x
+
+fn typed_version<comptime N: i32>() -> i32 {
+    return id(N) as! i32
+}
+
+fn untyped_version<comptime N>() -> i32 {
+    return id(N) as! i32
+}
+
+fn main() {
+    println("typed: {}", typed_version<comptime 10i32>())
+    println("untyped: {}", untyped_version<comptime 20>())
+}

samples/generics/typed_const_generic_bool.jakt

@@ -0,0 +1,13 @@
+/// Expect:
+/// - output: "true\nfalse\n"
+
+comptime id<T>(anon x: T) -> T => x
+
+fn is_enabled<comptime B: bool>() -> bool {
+    return id(B) as! bool
+}
+
+fn main() {
+    println("{}", is_enabled<comptime true>())
+    println("{}", is_enabled<comptime false>())
+}

samples/generics/typed_const_generic_i32.jakt

@@ -0,0 +1,12 @@
+/// Expect:
+/// - output: "42\n"
+
+comptime id<T>(anon x: T) -> T => x
+
+fn get_value<comptime N: i32>() -> i32 {
+    return id(N) as! i32
+}
+
+fn main() {
+    println("{}", get_value<comptime 42i32>())
+}

samples/generics/typed_const_generic_multiple.jakt

@@ -0,0 +1,14 @@
+/// Expect:
+/// - output: "30\n"
+
+comptime id<T>(anon x: T) -> T => x
+
+fn multiply<comptime A: i32, comptime B: i32>() -> i32 {
+    let a = id(A) as! i32
+    let b = id(B) as! i32
+    return a * b
+}
+
+fn main() {
+    println("{}", multiply<comptime 5i32, comptime 6i32>())
+}

samples/generics/typed_const_generic_u64.jakt

@@ -0,0 +1,12 @@
+/// Expect:
+/// - output: "110\n"
+
+comptime id<T>(anon x: T) -> T => x
+
+fn add_ten<comptime N: u64>() -> u64 {
+    return (id(N) as! u64) + 10u64
+}
+
+fn main() {
+    println("{}", add_ten<comptime 100u64>())
+}

samples/generics/typed_const_generic_with_type_param.jakt

@@ -0,0 +1,13 @@
+/// Expect:
+/// - output: "hello 5\n"
+
+comptime id<T>(anon x: T) -> T => x
+
+fn format_with_count<T, comptime N: i32>(anon value: T) throws -> String {
+    let count = id(N) as! i32
+    return format("{} {}", value, count)
+}
+
+fn main() {
+    println("{}", format_with_count<String, comptime 5i32>("hello"))
+}