feat: Add reminder functionality to ContractSigner model

- Added `last_reminder_mail_sent_at` field to track reminder
  timestamps.
- Implemented `can_send_reminder` to check if a reminder can be
  sent based on a 30-minute cooldown.
- Added `reminder_cooldown_remaining` to get remaining cooldown
  time.
- Added `mark_reminder_sent` to update reminder timestamp.
- Added example demonstrating reminder functionality in
  `legal_contract_example.rs`.
- Added tests for reminder functionality in
  `test_reminder_functionality.rs`.
- Updated Rhai scripts to include reminder-related functions and
  tests.
- Improved formatting and clarity in example code.

heromodels/examples/test_reminder_functionality.rs

@@ -0,0 +1,108 @@
+use heromodels::models::legal::{ContractSigner, SignerStatus};
+
+// Helper function to get current timestamp
+fn current_timestamp_secs() -> u64 {
+    std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_secs()
+}
+
+fn main() {
+    println!("Testing ContractSigner Reminder Functionality");
+    println!("==============================================\n");
+
+    // Test 1: Create a new signer (should have no reminder timestamp)
+    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!("  Last reminder: {:?}", signer.last_reminder_mail_sent_at);
+    assert_eq!(signer.last_reminder_mail_sent_at, None);
+    println!("  ✓ New signer has no reminder timestamp\n");
+
+    // Test 2: Check if reminder can be sent (should be true for new signer)
+    println!("Test 2: Can send reminder check");
+    let current_time = current_timestamp_secs();
+    let can_send = signer.can_send_reminder(current_time);
+    println!("  Can send reminder: {}", can_send);
+    assert!(can_send);
+    println!("  ✓ New signer can receive reminders\n");
+
+    // Test 3: Check cooldown remaining (should be None for new signer)
+    println!("Test 3: Cooldown remaining check");
+    let cooldown = signer.reminder_cooldown_remaining(current_time);
+    println!("  Cooldown remaining: {:?}", cooldown);
+    assert_eq!(cooldown, None);
+    println!("  ✓ New signer has no cooldown\n");
+
+    // Test 4: Mark reminder as sent
+    println!("Test 4: Mark reminder as sent");
+    signer.mark_reminder_sent(current_time);
+    println!("  Reminder marked as sent at: {}", current_time);
+    println!("  Last reminder timestamp: {:?}", signer.last_reminder_mail_sent_at);
+    assert_eq!(signer.last_reminder_mail_sent_at, Some(current_time));
+    println!("  ✓ Reminder timestamp updated correctly\n");
+
+    // Test 5: Check if reminder can be sent immediately after (should be false)
+    println!("Test 5: Immediate retry check");
+    let can_send_again = signer.can_send_reminder(current_time);
+    println!("  Can send reminder immediately: {}", can_send_again);
+    assert!(!can_send_again);
+    println!("  ✓ Cannot send reminder immediately after sending\n");
+
+    // Test 6: Check cooldown remaining (should be 30 minutes)
+    println!("Test 6: Cooldown after sending");
+    let cooldown_after = signer.reminder_cooldown_remaining(current_time);
+    println!("  Cooldown remaining: {:?} seconds", cooldown_after);
+    assert_eq!(cooldown_after, Some(30 * 60)); // 30 minutes = 1800 seconds
+    println!("  ✓ Cooldown is exactly 30 minutes\n");
+
+    // Test 7: Test after cooldown period
+    println!("Test 7: After cooldown period");
+    let future_time = current_time + (31 * 60); // 31 minutes later
+    let can_send_later = signer.can_send_reminder(future_time);
+    let cooldown_later = signer.reminder_cooldown_remaining(future_time);
+    println!("  Time: {} (31 minutes later)", future_time);
+    println!("  Can send reminder: {}", can_send_later);
+    println!("  Cooldown remaining: {:?}", cooldown_later);
+    assert!(can_send_later);
+    assert_eq!(cooldown_later, None);
+    println!("  ✓ Can send reminder after cooldown period\n");
+
+    // Test 8: Test builder pattern with reminder timestamp
+    println!("Test 8: Builder pattern with reminder timestamp");
+    let signer_with_reminder = ContractSigner::new(
+        "test-signer-002".to_string(),
+        "Another User".to_string(),
+        "another@example.com".to_string(),
+    )
+    .status(SignerStatus::Pending)
+    .last_reminder_mail_sent_at(current_time - (20 * 60)) // 20 minutes ago
+    .comments("Test signer with reminder");
+
+    println!("  Signer: {}", signer_with_reminder.name);
+    println!("  Last reminder: {:?}", signer_with_reminder.last_reminder_mail_sent_at);
+    println!("  Can send reminder: {}", signer_with_reminder.can_send_reminder(current_time));
+    
+    let remaining = signer_with_reminder.reminder_cooldown_remaining(current_time);
+    println!("  Cooldown remaining: {:?} seconds", remaining);
+    assert_eq!(remaining, Some(10 * 60)); // 10 minutes remaining
+    println!("  ✓ Builder pattern works correctly\n");
+
+    // Test 9: Test clear reminder timestamp
+    println!("Test 9: Clear reminder timestamp");
+    let cleared_signer = signer_with_reminder.clear_last_reminder_mail_sent_at();
+    println!("  Last reminder after clear: {:?}", cleared_signer.last_reminder_mail_sent_at);
+    println!("  Can send reminder: {}", cleared_signer.can_send_reminder(current_time));
+    assert_eq!(cleared_signer.last_reminder_mail_sent_at, None);
+    assert!(cleared_signer.can_send_reminder(current_time));
+    println!("  ✓ Clear reminder timestamp works correctly\n");
+
+    println!("All tests passed! ✅");
+    println!("ContractSigner reminder functionality is working correctly.");
+}