Add timeout parameter to metadata_server and chunk_server init/step functions

Unified the function signatures across all process types (metadata server,
chunk server, and simulation client) to accept an int *timeout parameter.
This provides consistency in the simulation framework and allows all
process types to control their wakeup times.

**Changes:**

**Headers (metadata_server.h, chunk_server.h):**
- Updated metadata_server_init() to accept int *timeout parameter
- Updated metadata_server_step() to accept int *timeout parameter
- Updated chunk_server_init() to accept int *timeout parameter
- Updated chunk_server_step() to accept int *timeout parameter

**Implementations (metadata_server.c, chunk_server.c):**
- Modified init functions to set *timeout = -1 (no timeout needed)
- Modified step functions to set *timeout = -1 (no timeout needed)
- Both server types currently don't require periodic wakeups, but the
  parameter allows for future timeout-based behavior

**System Integration (system.c):**
- Updated spawn_simulated_process() to declare timeout variable once
  and pass it to all process init functions uniformly
- Updated update_simulation() to declare timeout variable once and
  pass it to all process step functions uniformly
- Simplified control flow by removing special case for client timeout
  handling - now all process types use the same timeout logic
- Consolidated timeout-to-wakeup_time conversion after switch statements

**Benefits:**
- Consistent API across all process types
- Cleaner code with reduced duplication
- Future-proof for server timeout requirements
- All processes now managed uniformly by simulation framework

The simulation continues to run correctly with all process types
handling timeout parameter appropriately.

src/system.c

@@ -323,26 +323,19 @@ int spawn_simulated_process(char *args)
     void *contexts[MAX_CONNS+1];
     struct pollfd polled[MAX_CONNS+1];
     int num_polled;
+    int timeout = -1;
 
     current_process = process;
 
     switch (process->type) {
         case PROCESS_TYPE_METADATA_SERVER:
-            num_polled = metadata_server_init(&process->metadata_server, argc, argv, contexts, polled);
+            num_polled = metadata_server_init(&process->metadata_server, argc, argv, contexts, polled, &timeout);
             break;
         case PROCESS_TYPE_CHUNK_SERVER:
-            num_polled = chunk_server_init(&process->chunk_server, argc, argv, contexts, polled);
+            num_polled = chunk_server_init(&process->chunk_server, argc, argv, contexts, polled, &timeout);
             break;
         case PROCESS_TYPE_CLIENT:
-        {
-            int timeout = -1;
             num_polled = simulation_client_init(&process->simulation_client, argc, argv, contexts, polled, &timeout);
-            if (timeout < 0) {
-                process->wakeup_time = INVALID_TIME;
-            } else {
-                process->wakeup_time = current_time + timeout;
-            }
-        }
             break;
         default:
             num_polled = -1;
@@ -354,6 +347,12 @@ int spawn_simulated_process(char *args)
         // TODO
     }
 
+    if (timeout < 0) {
+        process->wakeup_time = INVALID_TIME;
+    } else {
+        process->wakeup_time = current_time + timeout;
+    }
+
     process_poll_array(process, contexts, polled, num_polled);
 
     processes[num_processes++] = process;
@@ -546,23 +545,16 @@ void update_simulation(void)
             }
         }
 
+        int timeout = -1;
         switch (current_process->type) {
             case PROCESS_TYPE_METADATA_SERVER:
-                num_polled = metadata_server_step(&current_process->metadata_server, contexts, polled, num_polled);
+                num_polled = metadata_server_step(&current_process->metadata_server, contexts, polled, num_polled, &timeout);
                 break;
             case PROCESS_TYPE_CHUNK_SERVER:
-                num_polled = chunk_server_step(&current_process->chunk_server, contexts, polled, num_polled);
+                num_polled = chunk_server_step(&current_process->chunk_server, contexts, polled, num_polled, &timeout);
                 break;
             case PROCESS_TYPE_CLIENT:
-            {
-                int timeout = -1;
                 num_polled = simulation_client_step(&current_process->simulation_client, contexts, polled, num_polled, &timeout);
-                if (timeout < 0) {
-                    current_process->wakeup_time = INVALID_TIME;
-                } else {
-                    current_process->wakeup_time = current_time + timeout;
-                }
-            }
                 break;
         }
 
@@ -570,6 +562,12 @@ void update_simulation(void)
             // TODO
         }
 
+        if (timeout < 0) {
+            current_process->wakeup_time = INVALID_TIME;
+        } else {
+            current_process->wakeup_time = current_time + timeout;
+        }
+
         process_poll_array(current_process, contexts, polled, num_polled);
 
         current_process = NULL;