Refactor task state–related operation APIs

This commit refactors all task operation APIs that are related to task
state transitions to support the new scheduler. The simplified
mo_enqueue_task() and mo_dequeue_task() routines are now invoked
directly inside these operations.

Enqueue and dequeue actions are performed only when the state
transition crosses the following groups:

  {TASK_RUNNING, TASK_READY} ↔ {other states}

The sections below describe the detailed changes for each API:

 - sched_wakeup_task(): Add TASK_RUNNING as part of the state-group
   complement, avoid running tasks enqueue again.

 - mo_task_cancel(): Cancel all tasks except TASK_RUNNING. If the task
   is in TASK_READY, mo_dequeue_task() is invoked before cancellation.

 - mo_task_delay(): Transition from TASK_RUNNING to TASK_BLOCKED;
   call mo_dequeue_task() accordingly.

 - mo_task_suspend(): This API can be called for both TASK_RUNNING and
   TASK_READY tasks. Both conditions require invoking mo_dequeue_task()
   before transitioning to TASK_SUSPEND.

 - mo_task_resume(): Transition from TASK_SUSPEND to TASK_READY;
   call mo_enqueue_task().

 - _sched_block(): Invoked only when a TASK_RUNNING task calls mutex-
   related APIs; performs the TASK_RUNNING → TASK_BLOCKED transition.

Author: vicLin8712

kernel/task.c

@@ -454,20 +454,15 @@ 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
-     */
-    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);
-    }
+    /* Enqueue task into ready queue */
+    if (task->state != TASK_READY && task->state != TASK_RUNNING)
+        sched_enqueue_task(task);
 }
 
 /* Efficient Round-Robin Task Selection with O(n) Complexity
@@ -879,6 +874,10 @@ int32_t mo_task_cancel(uint16_t id)
         }
     }
 
+    /* Remove from ready queue */
+    if (tcb->state == TASK_READY)
+        sched_dequeue_task(tcb);
+
     CRITICAL_LEAVE();
 
     /* Free memory outside critical section */
@@ -908,7 +907,9 @@ 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 */
+    sched_dequeue_task(self);
+
     self->delay = ticks;
     self->state = TASK_BLOCKED;
     NOSCHED_LEAVE();
@@ -935,6 +936,11 @@ 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)
+        sched_dequeue_task(task);
+
     task->state = TASK_SUSPENDED;
     bool is_current = (kcb->task_current == node);
 
@@ -963,9 +969,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;
@@ -1087,6 +1092,9 @@ void _sched_block(queue_t *wait_q)
 
     tcb_t *self = kcb->task_current->data;
 
+    /* Remove node from ready queue */
+    sched_dequeue_task(self);
+
     if (queue_enqueue(wait_q, self) != 0)
         panic(ERR_SEM_OPERATION);