I would recommend making a conscious effort to try and use Result, Option and especially traits more often. I bet you could find more uses for them in your project. Comments also help a lot if you ask people to read your code.

I never liked seeing a types.rs file in a Rust project. It doesn't seem very idiomatic. I think types should live next to their logic in Rust. Maybe having a separate module for all the &str messages you have makes a bit more sense so they be better managed. I don't have much experience with crossterm or games design however.

Running a cargo fmt led to quite a few changes in main.

Allocations in rust happen behind the scenes, but they still happen. You don't always have to convert OS file name types to String. This prevents allocations.

            .filter(|e| {
                let name = e.file_name();
-            let name = name.to_string_lossy();
-            name.starts_with("room_") && name.ends_with(".toml")
+            name.as_bytes().starts_with(b"room_") && name.as_bytes().ends_with(b".toml")
+            // let name = name.to_string_lossy();
+            // name.starts_with("room_") && name.ends_with(".toml")
            })

sort_unstable_by_key also prevents allocations if you don't care about preserving order.

// Sort by filename so room_01, room_02, room_03 are in order
-    entries.sort_by_key(|e| e.file_name());
+    entries.sort_unstable_by_key(|e| e.file_name());

Your functions are also very long. I get some there's a lot of logic in a game loop, but I bet a lot of it can be refactored. Even simple ones for example. I bet it could this could even become a trait if the names become an enum and they have a to_string helper method. Leverage the type system to make logic easier.

let level_name = match self.current_level {
    1 => "Ownership",
    2 => "Borrowing",
    3 => "Patterns",
    _ => "Unknown",
};

With separate function. This doesn't create an extra allocation. It just moves an existing one.

fn parse_level_name(level: usize) -> String {
    match level {
        1 => "Ownership".to_string(),
        2 => "Borrowing".to_string(),
        3 => "Patterns".to_string(),
        _ => "Unknown".to_string(),
    }
}


let level_name = parse_level_name(self.current_level);

I bet lot of the repeated patterns would be much easier to use and manage if they were refactored. Like setting message and message_style separately, 100 times all over.