content: add daily recaps (#3068)

This adds recap slides to the start of Day 2, 3, and 4 to reinforce
learning from the previous days.

Author: mgeisler

src/welcome-day-2.md

@@ -7,15 +7,15 @@ target_minutes: 180
 
 # Welcome to Day 2
 
-Now that we have seen a fair amount of Rust, today will focus on Rust's type
-system:
+We have covered the foundations of Rust:
 
-- Pattern matching: extracting data from structures.
-- Methods: associating functions with types.
-- Traits: behaviors shared by multiple types.
-- Generics: parameterizing types on other types.
-- Standard library types and traits: a tour of Rust's rich standard library.
-- Closures: function pointers with data.
+- **Basic Types:** Integers, booleans, characters, tuples, and arrays.
+- **Control Flow:** `if` expressions, loops, and `match` expressions.
+- **Functions:** How to define and call functions.
+- **User-Defined Types:** Model data with `struct` and `enum`.
+- **References:** Basic borrowing with `&` and `&mut`.
+
+You can now construct any type in Rust and implement basic logic!
 
 ## Schedule
 

src/welcome-day-3.md

@@ -7,11 +7,17 @@ target_minutes: 180
 
 # Welcome to Day 3
 
-Today, we will cover:
+We have now seen all the core language features:
 
-- Memory management, lifetimes, and the borrow checker: how Rust ensures memory
-  safety.
-- Smart pointers: standard library pointer types.
+- **Foundations:** Basic types, control flow, functions, and data structures.
+- **Pattern Matching:** Destructuring data effectively.
+- **Polymorphism:** Methods, Traits, and Generics.
+- **Standard Library:** Using essential types like `Option`, `Result`, `Vec`,
+  and `String`.
+- **Closures:** Anonymous functions that can capture their environment.
+
+You can write any type and associate behavior with it. We are now shifting gears
+to apply these concepts to memory management and system design.
 
 ## Schedule
 

src/welcome-day-4.md

@@ -7,13 +7,15 @@ target_minutes: 180
 
 # Welcome to Day 4
 
-Today we will cover topics relating to building large-scale software in Rust:
+We have mastered the core language and its unique safety model:
 
-- Iterators: a deep dive on the `Iterator` trait.
-- Modules and visibility.
-- Testing.
-- Error handling: panics, `Result`, and the try operator `?`.
-- Unsafe Rust: the escape hatch when you can't express yourself in safe Rust.
+- **Foundations & Abstraction:** Traits, generics, and the standard library.
+- **Ownership:** Move semantics and the `Drop` trait.
+- **Memory Management:** Borrowing rules (`&` vs `&mut`) and lifetimes.
+- **Smart Pointers:** `Box`, `Rc`, and `RefCell` for complex data structures.
+
+You now understand how Rust guarantees memory safety at compile time! Today we
+focus on applying this knowledge to build robust, large-scale applications.
 
 ## Schedule