Implement Gather command

[southforkcode]

Given we are in a day-by-day game loop cycle, we want to implement a command to gather resources. The player will issue the command at the beginning of the day:

>gather wood

And the game will gather on behalf of the player the specified resource. The resource list is know so the player can't arbitrarily gather random resources. The initial implementation should support gathering wood (fuel), water, and food for now.

Successful gathering of a resource should increment the player's resource count for that thing by 100.

So if the player has 23 food and they successfully gather food, the count should go up to 123.

We want tests to cover this mechanic.

[jmag-009]

For now let's assume the gather command will yield 100% success every time.

If a player enters >gather wood, the game should output Gathered 100 wood successfully!

Firstly, we need to implement a system that tracks and stores the resources a player has and their respective quantities. I will implement an inventory system that holds variants of an "Item" enum. <-- too much for now

I've also noticed the process_comand function doesn't have a feature that supports arguments so that will be implemented as well; a new args Vec parameter will be created for the function. The maximum amount of arguments for this command will be 1 for now.

[southforkcode]

We should implement a simple resource tracking mechanism. gather wood should add some random number of wood to the resource count. We can start with the resource being "fuel" but we will want to be able to translate wood to fuel but not vice-vesa.

[southforkcode]

Here is a design review for the gather feature, taking into account game design principles as well as the Rust best practices and testing requirements outlined in our GEMINI.md.

🎨 Game Design Comments

1. Time Consumption: The issue notes that the game loop is day-by-day. Just like the rest command, gather needs to cost a turn by incrementing the day_count (e.g. self.day_count += 1).
2. Resource Balancing: Incrementing by 100 is a good starting point, but we should consider if there is an inventory cap. If a player spams gather wood for 10 days, do they end up with 1000 wood, or is there a max carrying capacity? We might want to cap it (e.g., max_inventory_slots = 500) to encourage strategic choices.
3. Feedback to User: When a resource is gathered successfully, the game should output a clear resource summary so the player knows their new total, like: "You spent the day gathering wood. \n+100 Wood (Total: 123)"

🏗️ Architecture & Rust Implementation Design

1. Command Parsing Refactor:
   Currently, process_command uses a simplistic match cmd.as_str() block. Since the gather command introduces an argument (gather <resource>), this string matching won't scale.
   Recommendation: Extract command parsing into an enum.

   pub enum Command {
       Help,
       Rest,
       Quit,
       Gather(Resource),
       Unknown(String),
   }
   
   pub enum Resource {
       Wood,
       Water,
       Food,
   }

   Implement std::str::FromStr (or a custom parsing function) for Command so that GameEngine::process_command only ever matches on the Command enum, separating parsing logic from game state mutations.

2. Inventory Management:
   The Player struct currently only holds health.
   Recommendation: Introduce an Inventory component rather than adding arbitrary integer counters to the player.

   #[derive(Debug, Default)]
   pub struct Inventory {
       pub wood: u32,
       pub water: u32,
       pub food: u32,
   }

   This adheres to the GEMINI.md modularity rules and keeps Player clean.

3. Error Handling:
   If the user types >gather stone, the string parsing parser should gracefully return a helpful error like: "You can't gather that. Available resources: wood, water, food." This avoids unwraps or panics on unknown resources.

🧪 Testing Strategy

• BDD/Feature Tests: Since we prioritize BDD style tests for mechanics, the implementation should include a new .feature file (e.g., tests/features/gather.feature) that asserts:
  • Gathering wood successfully increases wood count by 100 and advances the day.
  • Gathering an unknown resource returns an error and does not advance the day.
• Unit Tests: Specifically add a module in src/engine.rs (or your command parser) to test the string-to-enum mappings and verify edge cases (like trailing whitespace: "gather wood ").