refactor: [#56] migrate DestroyCommandHandler to modular structure

Split destroy.rs (631 lines) into modular directory structure:
- destroy/mod.rs - Module documentation and public API
- destroy/handler.rs - Command handler implementation
- destroy/errors.rs - Error types with Traceable impl
- destroy/tests/ - Test organization (builders, integration)

All existing tests pass. No changes to business logic.

Co-authored-by: josecelano <58816+josecelano@users.noreply.github.com>

Author: Copilot

src/application/command_handlers/destroy/errors.rs

@@ -0,0 +1,76 @@
+//! Error types for the Destroy command handler
+
+use std::path::PathBuf;
+
+use crate::adapters::tofu::client::OpenTofuError;
+use crate::domain::environment::state::StateTypeError;
+use crate::shared::command::CommandError;
+
+/// Comprehensive error type for the `DestroyCommandHandler`
+#[derive(Debug, thiserror::Error)]
+pub enum DestroyCommandHandlerError {
+    #[error("OpenTofu command failed: {0}")]
+    OpenTofu(#[from] OpenTofuError),
+
+    #[error("Command execution failed: {0}")]
+    Command(#[from] CommandError),
+
+    #[error("Failed to persist environment state: {0}")]
+    StatePersistence(#[from] crate::domain::environment::repository::RepositoryError),
+
+    #[error("Invalid state transition: {0}")]
+    StateTransition(#[from] StateTypeError),
+
+    #[error("Failed to clean up state files at '{path}': {source}")]
+    StateCleanupFailed {
+        path: PathBuf,
+        #[source]
+        source: std::io::Error,
+    },
+}
+
+impl crate::shared::Traceable for DestroyCommandHandlerError {
+    fn trace_format(&self) -> String {
+        match self {
+            Self::OpenTofu(e) => {
+                format!("DestroyCommandHandlerError: OpenTofu command failed - {e}")
+            }
+            Self::Command(e) => {
+                format!("DestroyCommandHandlerError: Command execution failed - {e}")
+            }
+            Self::StatePersistence(e) => {
+                format!("DestroyCommandHandlerError: Failed to persist environment state - {e}")
+            }
+            Self::StateTransition(e) => {
+                format!("DestroyCommandHandlerError: Invalid state transition - {e}")
+            }
+            Self::StateCleanupFailed { path, source } => {
+                format!(
+                    "DestroyCommandHandlerError: Failed to clean up state files at '{}' - {source}",
+                    path.display()
+                )
+            }
+        }
+    }
+
+    fn trace_source(&self) -> Option<&dyn crate::shared::Traceable> {
+        match self {
+            Self::OpenTofu(e) => Some(e),
+            Self::Command(e) => Some(e),
+            Self::StatePersistence(_)
+            | Self::StateTransition(_)
+            | Self::StateCleanupFailed { .. } => None,
+        }
+    }
+
+    fn error_kind(&self) -> crate::shared::ErrorKind {
+        match self {
+            Self::OpenTofu(_) => crate::shared::ErrorKind::InfrastructureOperation,
+            Self::Command(_) => crate::shared::ErrorKind::CommandExecution,
+            Self::StateTransition(_) => crate::shared::ErrorKind::Configuration,
+            Self::StatePersistence(_) | Self::StateCleanupFailed { .. } => {
+                crate::shared::ErrorKind::StatePersistence
+            }
+        }
+    }
+}