refactor(Common): Complete transport layer refactoring to PascalCase naming

Major refactoring of the transport layer in the Common crate to align with PascalCase naming conventions per CLAUDE.md. All method names and struct fields renamed from snake_case to PascalCase (e.g., `send_request` -> `SendRequest`, `correlation_id` -> `CorrelationIdentifier`).

Key changes:
- TransportStrategy trait methods renamed to PascalCase
- UnifiedRequest/UnifiedResponse fields and methods updated
- TransportError restructured with renamed fields
- TransportConfig builder methods converted to PascalCase
- Added new transport components: CircuitBreaker, Retry, Metrics
- TransportTypeDetector now requires Send + Sync with instance methods
- Registry simplified to remove RwLock overhead

Added new dependencies: uuid (v4), log, tokio (full), rand to support circuit breaker and retry logic. This refactoring establishes the foundation for improved transport resilience and consistency with Land's naming standards.

Author: NikolaRHristov

Cargo.toml

@@ -18,10 +18,13 @@ thiserror = { workspace = true }
 url = { workspace = true }
 
 # Transport-specific dependencies
-uuid = { workspace = true }
+uuid = { workspace = true, features = ["v4"] }
 futures = { workspace = true }
 anyhow = { workspace = true }
 prometheus = { workspace = true }
+log = { workspace = true }
+tokio = { workspace = true, features = ["full"] }
+rand = { workspace = true }
 
 [features]
 default = []

Source/Transport/CircuitBreaker.rs

@@ -0,0 +1,69 @@
+#![allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
+//! # Circuit Breaker Pattern
+//!
+//! Circuit breaker implementation for transport fault tolerance.
+//! `CircuitBreakerState` lives in [`super::TransportStrategy`].
+
+use std::time::Duration;
+
+/// Configuration for the circuit breaker.
+#[derive(Debug, Clone)]
+pub struct CircuitBreakerConfiguration {
+	/// Number of consecutive failures before the circuit opens.
+	pub FailureThreshold: u32,
+	/// Duration to wait before transitioning to half-open.
+	pub ResetTimeout: Duration,
+	/// Successful requests in half-open state required to close the circuit.
+	pub SuccessThreshold: u32,
+}
+
+impl Default for CircuitBreakerConfiguration {
+	fn default() -> Self {
+		Self {
+			FailureThreshold: 5,
+			ResetTimeout: Duration::from_secs(60),
+			SuccessThreshold: 2,
+		}
+	}
+}
+
+/// Circuit breaker that wraps a transport to add fault-tolerance.
+///
+/// Tracks consecutive failures and opens the circuit when the
+/// `FailureThreshold` is exceeded, preventing cascading failures.
+#[derive(Debug, Clone)]
+pub struct CircuitBreaker {
+	Configuration: CircuitBreakerConfiguration,
+	FailureCount: u32,
+	IsOpen: bool,
+}
+
+impl CircuitBreaker {
+	/// Creates a new circuit breaker with the given configuration.
+	pub fn New(Configuration: CircuitBreakerConfiguration) -> Self {
+		Self {
+			Configuration,
+			FailureCount: 0,
+			IsOpen: false,
+		}
+	}
+
+	/// Returns `true` if the circuit allows requests through.
+	pub fn IsClosed(&self) -> bool {
+		!self.IsOpen
+	}
+
+	/// Records a successful request, resetting the failure counter.
+	pub fn RecordSuccess(&mut self) {
+		self.FailureCount = 0;
+		self.IsOpen = false;
+	}
+
+	/// Records a failed request, potentially opening the circuit.
+	pub fn RecordFailure(&mut self) {
+		self.FailureCount += 1;
+		if self.FailureCount >= self.Configuration.FailureThreshold {
+			self.IsOpen = true;
+		}
+	}
+}