Refactor: Modularize code structure for better maintainability

- Split HMM module into separate files (emission.rs, config.rs, model.rs, viterbi.rs, python_bindings.rs)
- Split MCMC module into separate files (proposal.rs, config.rs, likelihood.rs, sampler.rs, python_bindings.rs)
- Create organized src/hmm/ and src/mcmc/ directory structure
- Rename legacy files to hmm_legacy.rs and mcmc_legacy.rs for backward compatibility
- Update lib.rs to use new modular structure
- Reduce file sizes: largest file now 171 lines (previously 583 lines)
- Improve code reusability and maintainability
- All Python bindings remain backward compatible

src/hmm/config.rs

@@ -0,0 +1,114 @@
+//! Configuration and builder for HMM training
+//!
+//! Provides flexible configuration options using the builder pattern.
+
+use super::emission::EmissionModel;
+use crate::core::{OptimizrError, Result};
+
+/// HMM Configuration
+#[derive(Clone)]
+pub struct HMMConfig<E: EmissionModel> {
+    pub n_states: usize,
+    pub n_iterations: usize,
+    pub tolerance: f64,
+    pub emission_model: E,
+    pub use_parallel: bool,
+}
+
+impl<E: EmissionModel> HMMConfig<E> {
+    /// Create a new configuration builder
+    pub fn builder(n_states: usize) -> HMMConfigBuilder<E> {
+        HMMConfigBuilder::new(n_states)
+    }
+}
+
+/// Builder pattern for HMM configuration
+pub struct HMMConfigBuilder<E: EmissionModel> {
+    n_states: usize,
+    n_iterations: usize,
+    tolerance: f64,
+    emission_model: Option<E>,
+    use_parallel: bool,
+}
+
+impl<E: EmissionModel> HMMConfigBuilder<E> {
+    /// Create a new configuration builder
+    pub fn new(n_states: usize) -> Self {
+        Self {
+            n_states,
+            n_iterations: 100,
+            tolerance: 1e-6,
+            emission_model: None,
+            use_parallel: cfg!(feature = "parallel"),
+        }
+    }
+    
+    /// Set the number of EM iterations
+    pub fn iterations(mut self, n: usize) -> Self {
+        self.n_iterations = n;
+        self
+    }
+    
+    /// Set convergence tolerance
+    pub fn tolerance(mut self, tol: f64) -> Self {
+        self.tolerance = tol;
+        self
+    }
+    
+    /// Set custom emission model
+    pub fn emission_model(mut self, model: E) -> Self {
+        self.emission_model = Some(model);
+        self
+    }
+    
+    /// Enable/disable parallel computation
+    pub fn parallel(mut self, enabled: bool) -> Self {
+        self.use_parallel = enabled && cfg!(feature = "parallel");
+        self
+    }
+    
+    /// Build the configuration
+    pub fn build(self) -> Result<HMMConfig<E>>
+    where
+        E: EmissionModel + Default,
+    {
+        if self.n_states < 2 {
+            return Err(OptimizrError::InvalidParameter(
+                "n_states must be at least 2".to_string(),
+            ));
+        }
+        
+        Ok(HMMConfig {
+            n_states: self.n_states,
+            n_iterations: self.n_iterations,
+            tolerance: self.tolerance,
+            emission_model: self.emission_model.unwrap_or_default(),
+            use_parallel: self.use_parallel,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::hmm::emission::GaussianEmission;
+
+    #[test]
+    fn test_config_builder() {
+        let config = HMMConfig::<GaussianEmission>::builder(3)
+            .iterations(50)
+            .tolerance(1e-5)
+            .build()
+            .unwrap();
+        
+        assert_eq!(config.n_states, 3);
+        assert_eq!(config.n_iterations, 50);
+        assert_eq!(config.tolerance, 1e-5);
+    }
+
+    #[test]
+    fn test_invalid_states() {
+        let result = HMMConfig::<GaussianEmission>::builder(1).build();
+        assert!(result.is_err());
+    }
+}