Address remaining 13 PR comments on Commands v3 outline

This commit addresses the remaining 13 comments (beyond the initial 30) on PR #3166.

## binding-commands-to-triggers.rst (2 comments)
- Removed "How v3 triggers compare to v2 triggers" (migration guide content)
- Added note about potential updates from allwpilib PR #8366

## advanced-topics.rst (4 comments)
- Removed "Dynamic Command Generation" section entirely
- Removed "Resource pooling and management" from Advanced Async Patterns
- Changed "Priority conflicts and circular dependencies" to just "Priority conflicts"
- Removed "Memory leaks and resource exhaustion" from Edge Cases

## command-compositions.rst (2 comments)
- Removed "How v3 compositions compare to v2 command groups" (migration guide content)
- Added detailed explanation of parallel group implementation:
  - All groups (parallel/race/deadline) are parallel groups with different configs
  - Parallel groups have _n_ required and _m_ optional commands
  - Traditional parallel: _m_ = 0, Race: _n_ = 0, Deadline: both nonzero

## commands-and-coroutines.rst (5 comments)
- Changed "generator/yield paradigm" to "yield paradigm" (commands are void-returning)
- Removed "Comparison to v2's initialize/execute/end/isFinished pattern"
- Added compiler plugin note: checks for `yield` in while-loops only
- Added compiler plugin note: checks for unreachable code after `park()`
- Removed "Where properties should be set" from Command Properties (overlaps with creation patterns)
- Removed "How lifecycle differs from v2 commands" from Command Lifecycle

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: jasondaming

source/docs/software/commandbased/commands-v3/advanced-topics.rst

@@ -14,19 +14,6 @@
    - Best practices for base class design
    - Examples of useful base class patterns (describe scenarios, not full implementations)
 
-## Dynamic Command Generation
-
-.. todo::
-   Explain patterns for generating commands dynamically at runtime. Cover:
-   - When dynamic command generation is needed
-   - Creating commands from parameters/configuration
-   - Path planning and generated trajectories as commands
-   - Loading command sequences from files or network
-   - Command builders and fluent APIs
-   - Performance considerations for dynamic generation
-   - Memory management for dynamically created commands
-   - Examples of dynamic generation scenarios
-
 ## Performance Optimization
 
 .. todo::
@@ -48,7 +35,6 @@
    - State machines implemented with async/await
    - Error handling and recovery with async commands
    - Cancellation and timeout patterns
-   - Resource pooling and management
    - Coordinating multiple mechanisms with complex dependencies
    - Real-time responsive commands with background processing
    - Describe complex scenarios and how to implement them with v3 features
@@ -60,11 +46,10 @@
    - Commands that never yield (infinite loops without yield)
    - Forked commands and lifecycle management
    - Nested trigger scopes and cleanup
-   - Priority conflicts and circular dependencies
+   - Priority conflicts
    - Requirements conflicts with complex command compositions
    - Thread safety considerations (if any)
    - Limitations of the coroutine model
    - Breaking scheduler assumptions
-   - Memory leaks and resource exhaustion
    - Common mistakes and how to avoid them
    - What NOT to do in v3 commands

source/docs/software/commandbased/commands-v3/binding-commands-to-triggers.rst

@@ -12,7 +12,6 @@
    - When trigger bindings are evaluated by the scheduler
    - Available trigger sources (buttons, joysticks, sensors, custom)
    - High-level syntax for creating and binding triggers
-   - How v3 triggers compare to v2 triggers
 
 ## Button Bindings
 
@@ -49,6 +48,7 @@
    - Edge detection (rising/falling edges)
    - Trigger filtering and transformation
    - When composition is evaluated
+   - Note: This section may need updates if https://github.com/wpilibsuite/allwpilib/pull/8366 is merged
    - Examples of trigger composition patterns (describe what examples should show)
 
 ## Inner Trigger Scopes

source/docs/software/commandbased/commands-v3/command-compositions.rst

@@ -11,7 +11,6 @@
    - How compositions differ from async/await patterns
    - When to use compositions vs. async/await
    - Available composition types in v3
-   - How v3 compositions compare to v2 command groups
    - General syntax and usage patterns
 
 ## Sequence Groups
@@ -33,7 +32,13 @@
    Explain parallel command groups in detail. Cover:
    - What parallel groups do: run multiple commands simultaneously
    - How to create a parallel group
-   - When the parallel group completes (all commands finish)
+   - Note: All composition groups (parallel, race, deadline) are implemented as parallel groups with different configurations:
+     - Parallel groups have _n_ required commands and _m_ optional commands
+     - The group exits once all _n_ required commands have exited
+     - "Traditional" parallel groups: _m_ = 0 (every command is required)
+     - Race groups: _n_ = 0 (every command is optional, exits when any finishes)
+     - Deadline groups: both _n_ and _m_ are nonzero (mix of required and optional)
+     - Note: v2 deadlines were special case where _n_ = 1 and _m_ ≥ 1; v3 deadlines are generalized
    - Requirements handling with overlapping requirements
    - What happens if one command is interrupted
    - Common use cases for parallel groups

source/docs/software/commandbased/commands-v3/commands-and-coroutines.rst

@@ -21,9 +21,8 @@
    Provide an overview of what coroutines are and how v3 uses them. Cover:
    - High-level explanation of coroutines for teams unfamiliar with the concept
    - How coroutines enable sequential command logic without state machines
-   - The generator/yield paradigm
+   - The yield paradigm
    - How the scheduler executes coroutine commands
-   - Comparison to v2's initialize/execute/end/isFinished pattern
    - Benefits of the coroutine approach
 
 ## yield()
@@ -34,6 +33,7 @@
    - When to use yield() vs. other control flow primitives
    - How yield() relates to the scheduler loop timing
    - Common patterns using yield() (e.g., running for multiple cycles)
+   - Note: The compiler plugin checks for `yield` in while-loops (this check does not apply to other loop types)
    - Performance implications
    - Examples of yield() usage patterns (describe what examples should show)
 
@@ -44,6 +44,7 @@
    - What park() does: pause indefinitely until command is interrupted
    - When to use park() (e.g., commands that should run until interrupted)
    - How park() differs from yield() in a loop
+   - Note: The compiler plugin checks for unreachable code after a `park()` call
    - Interaction with command interruption and priorities
    - Common use cases for park()
    - Examples of park() usage patterns (describe what examples should show)
@@ -70,15 +71,13 @@
    - What happens when a command completes normally
    - What happens when a command is interrupted
    - Cleanup and resource management
-   - How lifecycle differs from v2 commands
 
 ## Command Properties
 
 .. todo::
    Explain the various properties that can be set on commands. Cover:
-   - How to set command properties (method chaining, decorators, etc.)
    - Available properties: name, priority, interruptible, runsWhenDisabled, etc.
+   - How to set command properties (method chaining, decorators, etc.)
    - When properties are evaluated vs. applied
    - How properties affect scheduler behavior
    - Best practices for setting properties
-   - Where properties should be set (factory vs. call site)