Implement sched_dequeue_task() to dequeue task from ready queue

Previously, mo_task_dequeue() was only a stub and returned immediately
without performing any operation. As a result, tasks remained in the
ready queue after being dequeued, leading to potential scheduler
inconsistencies.

This change implements the full dequeue process:
- Searches for the task node in the ready queue by task ID.
- Maintains RR cursor consistency: the RR cursor should always point
  to a valid task node in the ready queue. When removing a task node,
  the cursor is advanced circularly to the next node.
- Unlinks the task node using list_unlink(), which removes the node
  from the ready queue without freeing it. list_unlink() is used
  instead of list_remove() to avoid accidentally freeing
  kcb->task_current when the current running task is dequeued.
- Updates and checks queue_counts: if the ready queue becomes empty,
  the RR cursor is set to NULL and the bitmap is cleared until a new
  task is enqueued.

Author: vicLin8712

kernel/task.c

@@ -386,16 +386,34 @@ static void sched_enqueue_task(tcb_t *task)
     return;
 }
 
-/* Remove task from ready queues - state-based approach for compatibility */
-void sched_dequeue_task(tcb_t *task)
+/* Remove task from ready queue; return removed ready queue node */
+static __attribute__((unused)) list_node_t *sched_dequeue_task(tcb_t *task)
 {
     if (unlikely(!task))
-        return;
+        return NULL;
 
-    /* For tasks that need to be removed from ready state (suspended/cancelled),
-     * we rely on the state change. The scheduler will skip non-ready tasks
-     * when it encounters them during the round-robin traversal.
-     */
+    uint8_t prio_level = task->prio_level;
+
+    /* For task that need to be removed from ready/running state, it need be
+     * removed from corresponding ready queue. */
+    list_t *rq = kcb->harts->ready_queues[prio_level];
+    list_node_t *rq_node = list_foreach(rq, idcmp, (void *) (size_t) task->id);
+    list_node_t **cursor = &kcb->harts->rr_cursors[prio_level];
+    if (!rq_node)
+        return NULL;
+
+    /* Safely move cursor to next task node. */
+    if (rq_node == *cursor)
+        *cursor = list_cnext(rq, *cursor);
+
+    list_unlink(rq, rq_node);
+
+    /* Update task count in ready queue */
+    if (!--kcb->harts->queue_counts[prio_level]) {
+        *cursor = NULL;
+        BITMAP_CLEAN(task->prio_level);
+    }
+    return rq_node;
 }
 
 /* Handle time slice expiration for current task */