refactor: consolidate preflight cleanup modules

Move contents from preflight_cleanup_common.rs to preflight_cleanup.rs to
consolidate the preflight cleanup functionality into a single module.

This simplifies the module structure by:
- Removing the preflight_cleanup_common module
- Moving cleanup_build_directory and cleanup_templates_directory functions
- Preserving existing error types and compatibility
- Maintaining backward compatibility for imports

All tests, linting, and E2E functionality verified as working.

Author: josecelano

src/e2e/tasks/container/preflight_cleanup.rs

@@ -6,9 +6,8 @@
 //! directory cleanup operations.
 
 use crate::e2e::environment::TestEnvironment;
-use crate::e2e::tasks::preflight_cleanup::PreflightCleanupError;
-use crate::e2e::tasks::preflight_cleanup_common::{
-    cleanup_build_directory, cleanup_templates_directory,
+use crate::e2e::tasks::preflight_cleanup::{
+    cleanup_build_directory, cleanup_templates_directory, PreflightCleanupError,
 };
 use tracing::info;
 

src/e2e/tasks/mod.rs

@@ -22,18 +22,13 @@
 //! ### Virtual machine-specific tasks (`virtual_machine` submodule):
 //! - `run_provision_command` - Infrastructure provisioning via `OpenTofu`
 //! - `cleanup_infrastructure` - Infrastructure resource cleanup  
-//! - `preflight_cleanup` - VM-specific preflight cleanup (`OpenTofu` + LXD)
-//!
-//! ### Common functionality:
-//! - `preflight_cleanup_common` - Shared directory cleanup functions
-//! - `preflight_cleanup` - Legacy module with common error types and functions
+//! - `preflight_cleanup` - Shared directory cleanup functions and error types for both VM and container tests
 //!
 //! These tasks are orchestrated by the E2E test binaries to provide comprehensive
 //! testing coverage of the entire deployment system.
 
 pub mod container;
 pub mod preflight_cleanup;
-pub mod preflight_cleanup_common;
 pub mod run_configure_command;
 pub mod run_deployment_validation;
 pub mod run_test_command;

src/e2e/tasks/preflight_cleanup.rs

@@ -1,19 +1,14 @@
-//! Pre-flight cleanup module for E2E tests
+//! Generic preflight cleanup functionality
 //!
-//! This module provides functionality to clean up any lingering resources
-//! from previous test runs that may have been interrupted before cleanup.
-//!
-//! ## Migration Notice
-//!
-//! This module now serves as a compatibility layer that re-exports functions
-//! from the new modularized structure:
-//! - Container-specific functions are in `container::preflight_cleanup`
-//! - VM-specific functions are in `virtual_machine::preflight_cleanup`  
-//! - Common directory cleanup functions are in `preflight_cleanup_common`
+//! This module provides directory cleanup functions that are used by both
+//! container-based and VM-based E2E testing workflows. These functions handle
+//! the cleanup of build and template directories to ensure test isolation.
 
 use std::fmt;
 
+use crate::e2e::environment::TestEnvironment;
 use crate::infrastructure::adapters::opentofu::EmergencyDestroyError;
+use tracing::{info, warn};
 
 // Re-export functions from the new modular structure for backward compatibility
 pub use crate::e2e::tasks::container::preflight_cleanup::cleanup_lingering_resources;
@@ -52,3 +47,146 @@ impl std::error::Error for PreflightCleanupError {
         }
     }
 }
+
+/// Cleans the build directory to ensure fresh template state for E2E tests
+///
+/// This function removes the build directory if it exists, ensuring that
+/// E2E tests start with a clean state and don't use stale cached template files.
+///
+/// # Safety
+///
+/// This function is only intended for E2E test environments and should never
+/// be called in production code paths. It's designed to provide test isolation
+/// by ensuring fresh template rendering for each test run.
+///
+/// # Arguments
+///
+/// * `env` - The test environment containing configuration paths
+///
+/// # Returns
+///
+/// Returns `Ok(())` if cleanup succeeds or if the build directory doesn't exist.
+///
+/// # Errors
+///
+/// Returns a `PreflightCleanupError::ResourceConflicts` error if the build directory
+/// cannot be removed due to permission issues or file locks.
+pub fn cleanup_build_directory(env: &TestEnvironment) -> Result<(), PreflightCleanupError> {
+    let build_dir = &env.config.build_dir;
+
+    if !build_dir.exists() {
+        info!(
+            operation = "build_directory_cleanup",
+            status = "clean",
+            path = %build_dir.display(),
+            "Build directory doesn't exist, skipping cleanup"
+        );
+        return Ok(());
+    }
+
+    info!(
+        operation = "build_directory_cleanup",
+        path = %build_dir.display(),
+        "Cleaning build directory to ensure fresh template state"
+    );
+
+    match std::fs::remove_dir_all(build_dir) {
+        Ok(()) => {
+            info!(
+                operation = "build_directory_cleanup",
+                status = "success",
+                path = %build_dir.display(),
+                "Build directory cleaned successfully"
+            );
+            Ok(())
+        }
+        Err(e) => {
+            warn!(
+                operation = "build_directory_cleanup",
+                status = "failed",
+                path = %build_dir.display(),
+                error = %e,
+                "Failed to clean build directory"
+            );
+            Err(PreflightCleanupError::ResourceConflicts {
+                details: format!(
+                    "Failed to clean build directory '{}': {}",
+                    build_dir.display(),
+                    e
+                ),
+            })
+        }
+    }
+}
+
+/// Cleans the templates directory to ensure fresh embedded template extraction for E2E tests
+///
+/// This function removes the templates directory if it exists, ensuring that
+/// E2E tests start with fresh embedded templates and don't use stale cached template files.
+/// This is critical for testing template changes and instance name parameterization.
+///
+/// # Safety
+///
+/// This function is only intended for E2E test environments and should never
+/// be called in production code paths. It's designed to provide test isolation
+/// by ensuring fresh template extraction for each test run.
+///
+/// # Arguments
+///
+/// * `env` - The test environment containing configuration paths
+///
+/// # Returns
+///
+/// Returns `Ok(())` if cleanup succeeds or if the templates directory doesn't exist.
+///
+/// # Errors
+///
+/// Returns a `PreflightCleanupError::ResourceConflicts` error if the templates directory
+/// cannot be removed due to permission issues or file locks.
+pub fn cleanup_templates_directory(env: &TestEnvironment) -> Result<(), PreflightCleanupError> {
+    let templates_dir = std::path::Path::new(&env.config.templates_dir);
+
+    if !templates_dir.exists() {
+        info!(
+            operation = "templates_directory_cleanup",
+            status = "clean",
+            path = %templates_dir.display(),
+            "Templates directory doesn't exist, skipping cleanup"
+        );
+        return Ok(());
+    }
+
+    info!(
+        operation = "templates_directory_cleanup",
+        path = %templates_dir.display(),
+        "Cleaning templates directory to ensure fresh embedded template extraction"
+    );
+
+    match std::fs::remove_dir_all(templates_dir) {
+        Ok(()) => {
+            info!(
+                operation = "templates_directory_cleanup",
+                status = "success",
+                path = %templates_dir.display(),
+                "Templates directory cleaned successfully"
+            );
+            Ok(())
+        }
+        Err(e) => {
+            warn!(
+                operation = "templates_directory_cleanup",
+                status = "failed",
+                path = %templates_dir.display(),
+                error = %e,
+                "Failed to clean templates directory"
+            );
+            Err(PreflightCleanupError::ResourceConflicts {
+                details: format!(
+                    "Failed to clean templates directory '{}': {}",
+                    templates_dir.display(),
+                    e
+                ),
+            })
+        }
+    }
+}

src/e2e/tasks/preflight_cleanup_common.rs

@@ -5,9 +5,8 @@
 //! infrastructure resources including `OpenTofu` state and LXD instances.
 
 use crate::e2e::environment::TestEnvironment;
-use crate::e2e::tasks::preflight_cleanup::PreflightCleanupError;
-use crate::e2e::tasks::preflight_cleanup_common::{
-    cleanup_build_directory, cleanup_templates_directory,
+use crate::e2e::tasks::preflight_cleanup::{
+    cleanup_build_directory, cleanup_templates_directory, PreflightCleanupError,
 };
 use crate::infrastructure::adapters::lxd::client::LxdClient;
 use crate::infrastructure::adapters::opentofu::{self};