Integrate enqueue/dequeue logic into task control APIs

This commit integrates the refactored ready-queue enqueue and
dequeue logic into all task state transition APIs, completing the
scheduler behavior for runnable <-> non-runnable transitions.

APIs with dequeue logic added:
  - _sched_block(): TASK_RUNNING -> TASK_BLOCKED
  - mo_task_delay(): TASK_RUNNING -> TASK_BLOCKED
  - mo_task_cancel(): dequeue if the task is currently in the
    ready queue; the ready-queue node is now released inside the
    same critical section as the dequeue to avoid race conditions
    where a dequeued task would never return and its node would
    never be freed.
  - mo_task_suspend(): dequeue if the task is currently runnable

APIs with enqueue logic added:
  - sched_wakeup_task(): enqueue the task when it becomes runnable
  - mo_task_resume(): enqueue the task when transitioning from
    suspended to runnable

These updates ensure the task control APIs properly drive ready-
queue updates and maintain correct scheduler semantics across all
state transitions.

Author: vicLin8712

kernel/task.c

@@ -434,20 +434,16 @@ void sched_tick_current_task(void)
     }
 }
 
-/* Task wakeup - simple state transition approach */
+/* Task wakeup and enqueue into ready queue */
 void sched_wakeup_task(tcb_t *task)
 {
     if (unlikely(!task))
         return;
 
-    /* Mark task as ready - scheduler will find it during round-robin traversal
+    /* Enqueue task into ready queue for scheduler selection by rr_cursor.
      */
-    if (task->state != TASK_READY) {
-        task->state = TASK_READY;
-        /* Ensure task has time slice */
-        if (task->time_slice == 0)
-            task->time_slice = get_priority_timeslice(task->prio_level);
-    }
+    if (task->state != TASK_READY && task->state != TASK_RUNNING)
+        sched_enqueue_task(task);
 }
 
 /* Efficient Round-Robin Task Selection with O(n) Complexity
@@ -721,6 +717,12 @@ int32_t mo_task_cancel(uint16_t id)
         }
     }
 
+    /* Remove from ready queue */
+    if (tcb->state == TASK_READY) {
+        list_node_t *rq_node = sched_dequeue_task(tcb);
+        free(rq_node);
+    }
+
     CRITICAL_LEAVE();
 
     /* Free memory outside critical section */
@@ -751,7 +753,10 @@ void mo_task_delay(uint16_t ticks)
 
     tcb_t *self = kcb->task_current->data;
 
-    /* Set delay and blocked state - scheduler will skip blocked tasks */
+    /* Set delay and blocked state, dequeue from ready queue */
+    list_node_t *rq_node = sched_dequeue_task(self);
+    free(rq_node);
+
     self->delay = ticks;
     self->state = TASK_BLOCKED;
     NOSCHED_LEAVE();
@@ -778,8 +783,15 @@ int32_t mo_task_suspend(uint16_t id)
         return ERR_TASK_CANT_SUSPEND;
     }
 
+    /* Remove task node from ready queue if task is in ready queue
+     * (TASK_RUNNING/TASK_READY).*/
+    if (task->state == TASK_READY || task->state == TASK_RUNNING) {
+        list_node_t *rq_node = sched_dequeue_task(task);
+        free(rq_node);
+    }
+
     task->state = TASK_SUSPENDED;
-    bool is_current = (kcb->task_current == node);
+    bool is_current = (kcb->task_current->data == task);
 
     CRITICAL_LEAVE();
 
@@ -806,9 +818,8 @@ int32_t mo_task_resume(uint16_t id)
         CRITICAL_LEAVE();
         return ERR_TASK_CANT_RESUME;
     }
-
-    /* mark as ready - scheduler will find it */
-    task->state = TASK_READY;
+    /* Enqueue resumed task into ready queue */
+    sched_enqueue_task(task);
 
     CRITICAL_LEAVE();
     return ERR_OK;
@@ -922,6 +933,10 @@ void _sched_block(queue_t *wait_q)
 
     tcb_t *self = kcb->task_current->data;
 
+    /* Remove node from ready queue and free it */
+    list_node_t *node = sched_dequeue_task(self);
+    free(node);
+
     if (queue_enqueue(wait_q, self) != 0)
         panic(ERR_SEM_OPERATION);