docs: expand contract testing chapter (#66)

Closes #23

Resumen de revisión diferida:
- PR fusionado en modo autónomo autorizado.
- Validaciones locales y check remoto rust en verde.
- Sin dependencias, coautor ni estados reviewed o published.

Author: jeresoftx

Cargo.toml

@@ -90,3 +90,7 @@ path = "examples/soluciones/property_testing_nivel_2.rs"
 [[example]]
 name = "property_testing_nivel_3"
 path = "examples/soluciones/property_testing_nivel_3.rs"
+
+[[example]]
+name = "contract_testing"
+path = "examples/contract_testing.rs"

diagrams/06-contract-testing.mmd

@@ -0,0 +1,9 @@
+flowchart LR
+    C[Consumidor] --> R[Expectativa de operación]
+    R --> K[Contrato explícito]
+    K --> P[Proveedor]
+    P --> V{¿Cambio compatible?}
+    V -->|Sí| E[Verificación conserva expectativas]
+    V -->|No| M[Versionar o coordinar migración]
+    E --> D[Despliegue con menor incertidumbre]
+    M --> D

docs/06-contract-testing.md

@@ -48,4 +48,90 @@ contrato y razonar sobre compatibilidad sin agregar dependencias externas.
 El modelo representará la dirección del contrato, su compatibilidad y los
 riesgos que reducen la confianza de la verificación.
 
+## Teoría
+
+El contract testing parte de una frontera que ya existe: un consumidor necesita
+una operación y un proveedor la promete. La pregunta no es si ambos servicios
+funcionan aislados, sino si su lenguaje compartido sigue teniendo el mismo
+significado al evolucionar.
+
+La compatibilidad hacia atrás permite que consumidores existentes sigan usando
+el contrato. Cuando una modificación no lo permite, la solución no es ocultarla
+en un mock: se necesita una versión, una migración o coordinación explícita.
+
+## Diagrama
+
+```mermaid
+flowchart LR
+    C[Consumidor] --> R[Expectativa de operación]
+    R --> K[Contrato explícito]
+    K --> P[Proveedor]
+    P --> V{¿Cambio compatible?}
+    V -->|Sí| E[Verificación conserva expectativas]
+    V -->|No| M[Versionar o coordinar migración]
+    E --> D[Despliegue con menor incertidumbre]
+    M --> D
+```
+
+El archivo fuente vive en `diagrams/06-contract-testing.mmd`.
+
+## Complejidad
+
+El costo de un contrato crece con el número de consumidores y con la ambigüedad
+de sus expectativas. Una operación pequeña con errores explícitos suele ser más
+mantenible que una respuesta muy flexible cuyo significado depende de cada
+cliente.
+
+## Implementación
+
+`ContractDecision` en `src/contract_testing.rs` guarda la operación, la
+dirección del contrato, su compatibilidad y huecos como un cambio incompatible
+sin versionado o la ausencia de casos de error.
+
+```rust
+use rust_testing::contract_testing::{
+    Compatibility, ContractDecision, ContractDirection,
+};
+
+let contract = ContractDecision::new(
+    "consulta saldo",
+    ContractDirection::ConsumerToProvider,
+    Compatibility::BackwardCompatible,
+)?;
+
+assert_eq!(contract.compatibility(), Compatibility::BackwardCompatible);
+# Ok::<(), rust_testing::contract_testing::ContractError>(())
+```
+
+## Pruebas
+
+El módulo incluye pruebas unitarias, un consumidor externo en
+`tests/contract_testing.rs` y un doctest. El test externo garantiza que el
+modelo se pueda observar solo desde su API pública.
+
+## Benchmarks
+
+No hay benchmark propio. El modelo clasifica decisiones y no representa el
+costo de verificar contratos distribuidos reales. `cargo bench --all-targets`
+se conserva como verificación de ruta.
+
+## Ejemplos
+
+```bash
+cargo run --example contract_testing
+```
+
+El ejemplo muestra un contrato compatible y otro que es débil porque cambia sin
+versionarse.
+
+## Ejercicios
+
+Los ejercicios graduados y sus soluciones se agregan al cerrar el capítulo.
+
+## Referencias internas
+
+- RFC-0001 §13: Rust como núcleo técnico.
+- RFC-0001 §14: anatomía de cursos y capítulos.
+- RFC-0001 §20: revisión humana diferida.
+
 No está marcado como `reviewed` ni `published`.

examples/contract_testing.rs

@@ -0,0 +1,28 @@
+use rust_testing::contract_testing::{
+    Compatibility, ContractDecision, ContractDirection, ContractGap,
+};
+
+fn main() -> Result<(), rust_testing::contract_testing::ContractError> {
+    let compatible = ContractDecision::new(
+        "consulta saldo",
+        ContractDirection::ConsumerToProvider,
+        Compatibility::BackwardCompatible,
+    )?;
+    let breaking = ContractDecision::new(
+        "crea pedido",
+        ContractDirection::ProviderToConsumer,
+        Compatibility::CoordinatedChange,
+    )?
+    .with_gap(ContractGap::UnversionedBreakingChange);
+
+    for contract in [compatible, breaking] {
+        println!(
+            "{} => compatibilidad: {:?}, señal: {:?}, huecos: {:?}",
+            contract.operation(),
+            contract.compatibility(),
+            contract.signal(),
+            contract.gaps()
+        );
+    }
+    Ok(())
+}