Stop inline emits for IO control messages.

IO bind/unbind/finished events now use default Local emit so Pool<IOPool>
handlers are queued to the IO pool instead of running on the emitter thread.
Inline::NEVER on control handlers and Inline::ALWAYS bump reactions are kept.

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

Author: TrentHouliston

src/dsl/word/IO.hpp

@@ -30,7 +30,6 @@
 #include "../store/ThreadStore.hpp"
 #include "../trait/is_transient.hpp"
 #include "Single.hpp"
-#include "emit/Inline.hpp"
 
 namespace NUClear {
 namespace dsl {
@@ -132,13 +131,13 @@ namespace dsl {
             static void bind(const std::shared_ptr<threading::Reaction>& reaction, fd_t fd, event_t watch_set) {
 
                 reaction->unbinders.emplace_back([](const threading::Reaction& r) {
-                    r.reactor.emit<emit::Inline>(std::make_unique<operation::Unbind<IO>>(r.id));
+                    r.reactor.emit(std::make_unique<operation::Unbind<IO>>(r.id));
                 });
 
                 auto io_config = std::make_unique<IOConfiguration>(fd, watch_set, reaction);
 
                 // Send our configuration out
-                reaction->reactor.emit<emit::Inline>(io_config);
+                reaction->reactor.emit(io_config);
             }
 
             template <typename DSL>
@@ -155,7 +154,7 @@ namespace dsl {
 
             template <typename DSL>
             static void post_run(threading::ReactionTask& task) {
-                task.parent->reactor.emit<emit::Inline>(std::make_unique<IOFinished>(task.parent->id));
+                task.parent->reactor.emit(std::make_unique<IOFinished>(task.parent->id));
             }
         };
 

src/extension/IOController_Posix.ipp

@@ -169,8 +169,8 @@ namespace extension {
         // Start by rebuilding the list
         rebuild_list();
 
-        // Control handlers run on the IO pool at HIGH priority with Inline::NEVER so emit<Inline>
-        // cannot execute them on the default pool while ::poll() holds watches[]. Inline wake
+        // Control handlers run on the IO pool at HIGH priority with Inline::NEVER so they are
+        // always queued to the IO pool rather than running on the emitting thread. Inline wake
         // reactions registered after them only write to the notify pipe so ::poll() unblocks.
         on<Trigger<dsl::word::IOConfiguration>, Pool<IOPool>, Priority::HIGH, Inline::NEVER>().then(
             "Configure IO Reaction",