Fix lock ordering in dist_nifs.c to prevent SMP deadlocks

https://ampcode.com/threads/T-019ba265-8657-732e-a85b-9871a0214ae2

Fix lock ordering inversions in `dist_nifs.c` that can cause deadlocks under SMP when distribution connections are used concurrently with process termination.

## Problem

Similar to the recently fixed monitor/demonitor deadlock, `dist_nifs.c` calls `enif_demonitor_process` while holding the `remote_monitors` lock. Since `enif_demonitor_process` acquires `monitors` → `processes_table`, this creates an ABBA deadlock risk:

| Code Path | Lock Order |
|-----------|------------|
| `dist_connection_dtor` | `remote_monitors` → `monitors` → `processes_table` |
| `OPERATION_DEMONITOR_P` | `remote_monitors` → `monitors` → `processes_table` |
| `context_destroy` (firing resource monitors) | `processes_table` → `monitors` |

When a distribution connection is being destroyed while a monitored process is terminating, these paths can deadlock.

## Solution

Release the `remote_monitors` lock before calling `enif_demonitor_process`:

1. **`dist_connection_dtor`**: Move all monitors to a local list, unlock, then iterate and demonitor
2. **`OPERATION_DEMONITOR_P`**: Remove the found monitor from the list, unlock, then demonitor

This ensures consistent lock ordering: `processes_table` → `monitors` is always acquired before any synclist locks that might call back into the monitor/demonitor APIs.

Signed-off-by: Peter M <petermm@gmail.com>

Author: petermm

src/libAtomVM/dist_nifs.c

@@ -117,13 +117,19 @@ static void dist_connection_dtor(ErlNifEnv *caller_env, void *obj)
     struct ListHead *remote_monitors = synclist_wrlock(&conn_obj->remote_monitors);
     struct ListHead *item;
     struct ListHead *tmp;
+    struct ListHead to_demonitor;
+    list_init(&to_demonitor);
     MUTABLE_LIST_FOR_EACH (item, tmp, remote_monitors) {
+        list_remove(item);
+        list_append(&to_demonitor, item);
+    }
+    synclist_unlock(&conn_obj->remote_monitors);
+    MUTABLE_LIST_FOR_EACH (item, tmp, &to_demonitor) {
         struct RemoteMonitor *remote_monitor = GET_LIST_ENTRY(item, struct RemoteMonitor, head);
         enif_demonitor_process(caller_env, conn_obj, &remote_monitor->process_monitor);
         list_remove(item);
         free(item);
     }
-    synclist_unlock(&conn_obj->remote_monitors);
     synclist_destroy(&conn_obj->remote_monitors);
     struct ListHead *pending_packets = synclist_wrlock(&conn_obj->pending_packets);
     MUTABLE_LIST_FOR_EACH (item, tmp, pending_packets) {
@@ -531,20 +537,24 @@ static term nif_erlang_dist_ctrl_put_data(Context *ctx, int argc, term argv[])
             term monitor_ref = term_get_tuple_element(control, 3);
             uint8_t ref_len = term_get_external_reference_len(monitor_ref);
             const uint32_t *ref_words = term_get_external_reference_words(monitor_ref);
+            struct RemoteMonitor *found_monitor = NULL;
             struct ListHead *remote_monitors = synclist_wrlock(&conn_obj->remote_monitors);
             struct ListHead *item;
             LIST_FOR_EACH (item, remote_monitors) {
                 struct RemoteMonitor *remote_monitor = GET_LIST_ENTRY(item, struct RemoteMonitor, head);
                 if (remote_monitor->target_proc == target_proc
                     && remote_monitor->ref_len == ref_len
                     && memcmp(remote_monitor->ref_words, ref_words, ref_len * sizeof(uint32_t)) == 0) {
-                    enif_demonitor_process(erl_nif_env_from_context(ctx), conn_obj, &remote_monitor->process_monitor);
                     list_remove(item);
-                    free(remote_monitor);
+                    found_monitor = remote_monitor;
                     break;
                 }
             }
             synclist_unlock(&conn_obj->remote_monitors);
+            if (found_monitor) {
+                enif_demonitor_process(erl_nif_env_from_context(ctx), conn_obj, &found_monitor->process_monitor);
+                free(found_monitor);
+            }
             break;
         }
         case OPERATION_SEND_SENDER: {