Add enqueue and dequeue paths to task operation APIs

Previously, task operation APIs such as sched_wakeup_task() only updated
the task state, which was sufficient when scheduling relied on the global
task list. With the scheduler now selecting runnable tasks from
ready_queue[] per priority level, state changes alone are insufficient.

To support the new scheduler and to prevent selection of tasks that have
already left the runnable set, explicit enqueue and dequeue paths are
required when task state transitions cross the runnable boundary:

    In ready-queue set: {TASK_RUNNING, TASK_READY}
    Not in ready-queue set: {all other states}

This change updates task operation APIs to include queue insertion and
removal logic according to their semantics. In general, queue operations
are performed by invoking existing helper functions sched_enqueue_task()
and sched_dequeue_task().

The modified APIs include:

  - sched_wakeup_task(): avoid enqueueing a task that is already running
    by treating TASK_RUNNING as part of the runnable set complement.

  - mo_task_cancel(): dequeue TASK_READY tasks from ready_queue[] before
    cancelling, ensuring removed tasks are not scheduled again.

  - mo_task_delay(): runnable boundary transition only ("TASK_RUNNING →
    TASK_BLOCKED"), no queue insertion for non-runnable tasks.

  - mo_task_suspend(): supports both TASK_RUNNING and TASK_READY
    ("TASK_RUNNING/TASK_READY → TASK_SUSPENDED"), dequeue before suspend
    when necessary.

  - mo_task_resume(): only for suspended tasks ("TASK_SUSPENDED →
    TASK_READY"), enqueue into ready_queue[] on resume.

  - _sched_block(): runnable boundary transition only ("TASK_RUNNING →
    TASK_BLOCKED"), dequeue without memory free.

This change keeps task state transition consistent to the ready queue
semantic.

Author: vicLin8712

kernel/task.c

@@ -439,20 +439,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
@@ -864,6 +859,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 */
@@ -893,7 +892,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();
@@ -920,6 +921,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->data == task);
 
@@ -948,9 +954,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;
@@ -1072,6 +1077,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);