feat: Add signature functionality to ContractSigner

- Add `signature_data` field to `ContractSigner` to store base64
  encoded signature image data.  Allows for storing visual
  signatures alongside electronic ones.
- Implement `sign` method for `ContractSigner` to handle signing
  with optional signature data and comments. Improves the
  flexibility and expressiveness of the signing process.
- Add Rhai functions for signature management, including signing
  with/without data and clearing signature data.  Extends the
  Rhai scripting capabilities for contract management.
- Add comprehensive unit tests to cover the new signature
  functionality. Ensures correctness and robustness of the
  implementation.
- Update examples to demonstrate the new signature functionality.
  Provides clear usage examples for developers.

heromodels/examples/test_signature_functionality.rs

@@ -0,0 +1,163 @@
+use heromodels::models::legal::{ContractSigner, SignerStatus};
+
+fn main() {
+    println!("Testing ContractSigner Signature Functionality");
+    println!("==============================================\n");
+
+    // Test 1: Create a new signer (should have no signature data)
+    println!("Test 1: New signer creation");
+    let mut signer = ContractSigner::new(
+        "test-signer-001".to_string(),
+        "Test User".to_string(),
+        "test@example.com".to_string(),
+    );
+    
+    println!("  Signer created: {}", signer.name);
+    println!("  Status: {:?}", signer.status);
+    println!("  Signature data: {:?}", signer.signature_data);
+    assert_eq!(signer.signature_data, None);
+    assert_eq!(signer.status, SignerStatus::Pending);
+    println!("  ✓ New signer has no signature data and is pending\n");
+
+    // Test 2: Sign with signature data
+    println!("Test 2: Sign with signature data");
+    let signature_data = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==".to_string();
+    let comments = "I agree to all terms and conditions.".to_string();
+    
+    signer.sign(Some(signature_data.clone()), Some(comments.clone()));
+    
+    println!("  Status after signing: {:?}", signer.status);
+    println!("  Signed at: {:?}", signer.signed_at);
+    println!("  Comments: {:?}", signer.comments);
+    println!("  Signature data length: {}", signer.signature_data.as_ref().unwrap().len());
+    
+    assert_eq!(signer.status, SignerStatus::Signed);
+    assert!(signer.signed_at.is_some());
+    assert_eq!(signer.signature_data, Some(signature_data));
+    assert_eq!(signer.comments, Some(comments));
+    println!("  ✓ Signing with signature data works correctly\n");
+
+    // Test 3: Sign without signature data
+    println!("Test 3: Sign without signature data");
+    let mut signer2 = ContractSigner::new(
+        "test-signer-002".to_string(),
+        "Test User 2".to_string(),
+        "test2@example.com".to_string(),
+    );
+    
+    signer2.sign(None, Some("Electronic signature without visual data".to_string()));
+    
+    println!("  Status: {:?}", signer2.status);
+    println!("  Signature data: {:?}", signer2.signature_data);
+    println!("  Comments: {:?}", signer2.comments);
+    
+    assert_eq!(signer2.status, SignerStatus::Signed);
+    assert_eq!(signer2.signature_data, None);
+    assert!(signer2.comments.is_some());
+    println!("  ✓ Signing without signature data works correctly\n");
+
+    // Test 4: Sign with no comments or signature
+    println!("Test 4: Simple signing (no signature, no comments)");
+    let mut signer3 = ContractSigner::new(
+        "test-signer-003".to_string(),
+        "Test User 3".to_string(),
+        "test3@example.com".to_string(),
+    );
+    
+    signer3.sign(None, None);
+    
+    println!("  Status: {:?}", signer3.status);
+    println!("  Signature data: {:?}", signer3.signature_data);
+    println!("  Comments: {:?}", signer3.comments);
+    
+    assert_eq!(signer3.status, SignerStatus::Signed);
+    assert_eq!(signer3.signature_data, None);
+    assert_eq!(signer3.comments, None);
+    println!("  ✓ Simple signing works correctly\n");
+
+    // Test 5: Builder pattern with signature data
+    println!("Test 5: Builder pattern with signature data");
+    let signer_with_signature = ContractSigner::new(
+        "test-signer-004".to_string(),
+        "Builder User".to_string(),
+        "builder@example.com".to_string(),
+    )
+    .status(SignerStatus::Pending)
+    .signature_data("data:image/png;base64,example")
+    .comments("Pre-signed with builder pattern");
+
+    println!("  Signer: {}", signer_with_signature.name);
+    println!("  Status: {:?}", signer_with_signature.status);
+    println!("  Signature data: {:?}", signer_with_signature.signature_data);
+    println!("  Comments: {:?}", signer_with_signature.comments);
+    
+    assert_eq!(signer_with_signature.signature_data, Some("data:image/png;base64,example".to_string()));
+    println!("  ✓ Builder pattern with signature data works correctly\n");
+
+    // Test 6: Clear signature data
+    println!("Test 6: Clear signature data");
+    let cleared_signer = signer_with_signature.clear_signature_data();
+    println!("  Signature data after clear: {:?}", cleared_signer.signature_data);
+    assert_eq!(cleared_signer.signature_data, None);
+    println!("  ✓ Clear signature data works correctly\n");
+
+    // Test 7: Serialization/Deserialization test
+    println!("Test 7: Serialization/Deserialization");
+    let original_signer = ContractSigner::new(
+        "serialize-test".to_string(),
+        "Serialize User".to_string(),
+        "serialize@example.com".to_string(),
+    )
+    .signature_data("test-signature-data")
+    .comments("Test serialization");
+
+    // Serialize to JSON
+    let json = serde_json::to_string(&original_signer).expect("Failed to serialize");
+    println!("  Serialized JSON length: {} characters", json.len());
+    
+    // Deserialize from JSON
+    let deserialized_signer: ContractSigner = serde_json::from_str(&json).expect("Failed to deserialize");
+    
+    println!("  Original signature data: {:?}", original_signer.signature_data);
+    println!("  Deserialized signature data: {:?}", deserialized_signer.signature_data);
+    
+    assert_eq!(original_signer.signature_data, deserialized_signer.signature_data);
+    assert_eq!(original_signer.name, deserialized_signer.name);
+    assert_eq!(original_signer.email, deserialized_signer.email);
+    println!("  ✓ Serialization/Deserialization works correctly\n");
+
+    // Test 8: Backward compatibility test
+    println!("Test 8: Backward compatibility");
+    // Simulate old JSON without signature_data field
+    let old_json = r#"{
+        "id": "old-signer",
+        "name": "Old User",
+        "email": "old@example.com",
+        "status": "Pending",
+        "signed_at": null,
+        "comments": null,
+        "last_reminder_mail_sent_at": null
+    }"#;
+    
+    let old_signer: ContractSigner = serde_json::from_str(old_json).expect("Failed to deserialize old format");
+    println!("  Old signer name: {}", old_signer.name);
+    println!("  Old signer signature data: {:?}", old_signer.signature_data);
+    
+    assert_eq!(old_signer.signature_data, None);
+    println!("  ✓ Backward compatibility works correctly\n");
+
+    println!("All tests passed! ✅");
+    println!("ContractSigner signature functionality is working correctly.");
+    
+    // Summary
+    println!("\n📋 Summary of Features Tested:");
+    println!("  ✅ New signer creation (signature_data: None)");
+    println!("  ✅ Signing with signature data");
+    println!("  ✅ Signing without signature data");
+    println!("  ✅ Simple signing (no data, no comments)");
+    println!("  ✅ Builder pattern with signature data");
+    println!("  ✅ Clear signature data functionality");
+    println!("  ✅ JSON serialization/deserialization");
+    println!("  ✅ Backward compatibility with old data");
+    println!("\n🎯 Ready for production use!");
+}