docs: fix review comments (spelling, scope table, defaults)

Author: TrentHouliston

docs/reference/api/reactor.md

@@ -95,7 +95,7 @@ All DSL words are aliased so they can be used without namespace qualification:
 | `UDP`                        | UDP socket events                     |
 | `TCP`                        | TCP socket events                     |
 | `Network<T>`                 | Networked data                        |
-| `Sync<T>`                    | Synchronisation group                 |
+| `Sync<T>`                    | Synchronization group                 |
 | `Single`                     | At most one task at a time            |
 | `Buffer<N>`                  | Allow up to N concurrent tasks        |
 | `Pool<T>`                    | Execute on a named thread pool        |
@@ -125,15 +125,15 @@ static constexpr LogLevel FATAL = LogLevel::FATAL;
 
 Accessed via the nested `Scope` struct:
 
-| Scope                  | Description                    |
-| ---------------------- | ------------------------------ |
-| `Scope::LOCAL<T>`      | Default; tasks via thread pool |
-| `Scope::INLINE<T>`     | Execute in the emitting thread |
-| `Scope::DELAY<T>`      | Delayed emission               |
-| `Scope::INITIALIZE<T>` | Available before startup       |
-| `Scope::NETWORK<T>`    | Broadcast over network         |
-| `Scope::UDP<T>`        | Emit via UDP                   |
-| `Scope::WATCHDOG<T>`   | Service a watchdog             |
+| Scope               | Description                    |
+| ------------------- | ------------------------------ |
+| `Scope::LOCAL`      | Default; tasks via thread pool |
+| `Scope::INLINE`     | Execute in the emitting thread |
+| `Scope::DELAY`      | Delayed emission               |
+| `Scope::INITIALIZE` | Available before startup       |
+| `Scope::NETWORK`    | Broadcast over network         |
+| `Scope::UDP`        | Emit via UDP                   |
+| `Scope::WATCHDOG`   | Service a watchdog             |
 
 ## Example
 

docs/reference/dsl/group.md

@@ -18,13 +18,13 @@ on<Trigger<T>, Group<GroupType>>()
 
 ```cpp
 struct GroupType {
-    static constexpr int concurrency = N;
+    static constexpr int concurrency = N;  // defaults to 1 if omitted
 };
 ```
 
 ## Behavior
 
-- At most `GroupType::concurrency` tasks from the group execute simultaneously.
+- At most `GroupType::concurrency` tasks from the group execute simultaneously (defaults to 1 if omitted).
 - Tasks that exceed the concurrency limit are queued and dispatched by priority.
 - Groups are identified by type — the same `GroupType` used in different reactors refers to the same group.
 - A reaction can belong to multiple groups.

docs/reference/dsl/inline.md

@@ -11,15 +11,15 @@ on<Trigger<T>, Inline::NEVER>().then([](const T& t) { /* ... */ });
 
 ## Modes
 
-| Mode             | Behaviour                                                                 |
+| Mode             | Behavior                                                                  |
 | ---------------- | ------------------------------------------------------------------------- |
 | `Inline::ALWAYS` | Task runs immediately on the emitting thread, bypassing the scheduler.    |
 | `Inline::NEVER`  | Task is always queued to the thread pool, even from an inline emit scope. |
 | *(default)*      | NEUTRAL — respects the emit scope used by the caller.                     |
 
 If both `Inline::ALWAYS` and `Inline::NEVER` are specified on the same reaction, a `std::logic_error` is thrown at binding time.
 
-## Behaviour
+## Behavior
 
 ```mermaid
 flowchart LR

docs/reference/dsl/pool.md

@@ -16,10 +16,10 @@ on<Trigger<T>, Pool<PoolType>>().then([](const T& data) {
 
 The struct must satisfy:
 
-| Member        | Type                           | Description                                          |
-| ------------- | ------------------------------ | ---------------------------------------------------- |
-| `name`        | `static constexpr const char*` | Name assigned to pool threads (visible in debuggers) |
-| `concurrency` | `static constexpr int`         | Number of threads in the pool                        |
+| Member        | Type                           | Description                                                                    |
+| ------------- | ------------------------------ | ------------------------------------------------------------------------------ |
+| `name`        | `static constexpr const char*` | Optional. Name assigned to pool threads (defaults to the demangled type name). |
+| `concurrency` | `static constexpr int`         | Required. Number of threads in the pool.                                       |
 
 ```cpp
 struct GPUPool {

docs/reference/dsl/priority.md

@@ -22,7 +22,7 @@ on<Trigger<T>, Priority::IDLE>()
 | LOW      | 250   | Background processing           |
 | IDLE     | 0     | Only when nothing else to do    |
 
-## Behaviour
+## Behavior
 
 Higher priority tasks are dequeued before lower priority tasks when a thread becomes available.
 Priority affects only queuing order — it does not preempt tasks that are already running.