Fix MSVC switch cases and scope pool priority elevation.

Qualify PriorityLevel cases for Windows and switch on priority() for
portability; limit HIGHEST thread priority to dequeue so ChronoController
is not starved on macOS.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: TrentHouliston

src/threading/scheduler/Pool.cpp

@@ -289,11 +289,14 @@ namespace threading {
             consumer_thread_id = std::this_thread::get_id();
             Pool::current_pool = this;
             try {
-                // Set the thread priority to highest while getting tasks
-                // This means that this thread will be a FIFO queued task on linux so it won't timeslice
-                const util::ThreadPriority priority_lock(PriorityLevel::HIGHEST);
                 while (true) {
-                    Task task = get_task();
+                    Task task;
+                    {
+                        // Elevate priority only while dequeuing so Linux workers stay FIFO-scheduled
+                        // without starving other pools (e.g. ChronoController's Always thread).
+                        const util::ThreadPriority priority_lock(PriorityLevel::HIGHEST);
+                        task = get_task();
+                    }
                     task.task->run();
                 }
             }

src/util/ThreadPriority.cpp

@@ -32,15 +32,15 @@ namespace util {
 
     void set_current_thread_priority(const PriorityLevel& priority) noexcept {
 
-        switch (priority) {
-            case IDLE: SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_IDLE); break;
-            case LOWEST: SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_LOWEST); break;
-            case LOW: SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_BELOW_NORMAL); break;
+        switch (priority()) {
+            case PriorityLevel::IDLE: SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_IDLE); break;
+            case PriorityLevel::LOWEST: SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_LOWEST); break;
+            case PriorityLevel::LOW: SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_BELOW_NORMAL); break;
             default:  // Default to normal if someone broke the enum
-            case NORMAL: SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_NORMAL); break;
-            case HIGH: SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL); break;
-            case HIGHEST: SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST); break;
-            case REALTIME: SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL); break;
+            case PriorityLevel::NORMAL: SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_NORMAL); break;
+            case PriorityLevel::HIGH: SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL); break;
+            case PriorityLevel::HIGHEST: SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST); break;
+            case PriorityLevel::REALTIME: SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL); break;
         }
     }
 
@@ -123,7 +123,7 @@ namespace util {
 
     void set_current_thread_priority(const PriorityLevel& priority) noexcept {
         sched_param param{};
-        switch (priority) {
+        switch (priority()) {
             case PriorityLevel::IDLE:
                 param.sched_priority = min_rr_priority + 0 * step_rr_priority;
                 pthread_setschedparam(pthread_self(), SCHED_RR, &param);
@@ -182,7 +182,7 @@ namespace util {
     }
 
     void set_current_thread_priority(const PriorityLevel& priority) noexcept {
-        switch (priority) {
+        switch (priority()) {
             case PriorityLevel::IDLE: pthread_set_qos_class_self_np(QOS_CLASS_BACKGROUND, 0); break;
             case PriorityLevel::LOWEST: pthread_set_qos_class_self_np(QOS_CLASS_UTILITY, 0); break;
             case PriorityLevel::LOW: pthread_set_qos_class_self_np(QOS_CLASS_UTILITY, -1); break;