Preserve module load order in CONFIG REWRITE (valkey-io#3769)

## Why

`CONFIG REWRITE` did not preserve module load order because the module
registry was stored in a hash table with unspecified iteration order.

This could write dependent modules before their dependencies, causing
the next restart to fail. Runtime `MODULE LOAD` and `MODULE UNLOAD`
operations could also change the resulting order.

## Fix

Use a single ordered list as the module registry instead of maintaining
a module dictionary and a separate load-order structure.

- Register modules at the tail of the list.
- Perform name lookups by scanning the list case-insensitively.
- Remove modules directly from the list when unloaded.
- Iterate the same list when writing `loadmodule` directives during
`CONFIG REWRITE`.
- Unload modules in reverse load order so dependents are unloaded before
their dependencies.

Module counts are normally small, so linear lookup keeps the
implementation simple while preserving load order as a single source of
truth.

Reloading a module moves it to the tail, reflecting its new load time.

## Tests

The module API tests verify that:

1. `CONFIG REWRITE` preserves module load order.
2. Static modules such as `lua` are not written to the configuration.
3. A rejected unload does not change the rewritten module order.
4. Unloading and reloading a module moves it to the tail.
5. The server can restart from the rewritten configuration.

Fixes valkey-io#3119

---------

Signed-off-by: Taeknology <20297177+Taeknology@users.noreply.github.com>

Author: Taeknology

src/config.c

@@ -1662,23 +1662,23 @@ static void rewriteConfigSocketBindOption(standardConfig *config, const char *na
 
 /* Rewrite the loadmodule option. */
 void rewriteConfigLoadmoduleOption(struct rewriteConfigState *state) {
-    if (dictSize(modules) == 0) {
+    if (listLength(modules) == 0) {
         rewriteConfigMarkAsProcessed(state, "loadmodule");
         return;
     }
 
     sds line;
+    listIter li;
+    listNode *ln;
 
-    dictIterator *di = dictGetIterator(modules);
-    dictEntry *de;
-    while ((de = dictNext(di)) != NULL) {
-        struct ValkeyModule *module = dictGetVal(de);
+    listRewind(modules, &li);
+    while ((ln = listNext(&li)) != NULL) {
+        struct ValkeyModule *module = listNodeValue(ln);
         if (module->is_static_module) continue;
         line = moduleLoadQueueEntryToLoadmoduleOptionStr(module, "loadmodule");
         rewriteConfigRewriteLine(state, "loadmodule", line, 1);
     }
-    dictReleaseIterator(di);
-    /* Mark "loadmodule" as processed in case modules is empty. */
+    /* Mark "loadmodule" as processed in case no modules are loaded. */
     rewriteConfigMarkAsProcessed(state, "loadmodule");
 }