refactor(tests): reorganize test architecture and enhance debugging capabilities

This change restructures the test suite for the person management zome as part
of the ongoing Phase 1 completion plan for the Nondominium Holochain hApp.

Based on recent development context, this addresses testing infrastructure
needs identified during the move toward Alpha testing scheduled for July 29th.
The project has been focusing on completing the person management foundation
before implementing resource and governance layers.

Key structural changes:
- Move tests from generic `nondominium/` to domain-specific `person/` directory
- Consolidate test utilities into shared `utils.ts` and `types.d.ts` files
- Replace general TEST_STRATEGY.md with specialized debug test suite
- Enhanced debug logging in zome_person with detailed DHT operation tracking

Technical improvements:
- Added comprehensive debug test suite covering all person management workflows
- Improved error visibility with step-by-step DHT synchronization logging
- Enhanced test utilities for multi-agent scenarios and timing analysis
- Better separation of concerns between foundation, integration, and scenario tests

Debug enhancements in zome_person:
- Added detailed logging for person creation and anchor link operations
- Enhanced get_all_agents function with comprehensive debug output
- Improved error handling and visibility for DHT hash operations

This reorganization supports the upcoming capability-based access control
migration and prepares the testing infrastructure for resource and governance
zome integration in Phase 2.

Author: Soushi888

dnas/nondominium/zomes/coordinator/zome_person/src/lib.rs

@@ -80,22 +80,28 @@ pub fn create_person(input: CreatePersonInput) -> ExternResult<CreatePersonOutpu
 
     let person = Person {
         agent_pub_key: agent_info.agent_initial_pubkey.clone(),
-        name: input.name,
+        name: input.name.clone(),
         avatar_url: input.avatar_url,
         created_at: now,
     };
 
+    debug!("Creating person: {}", person.name);
     let person_hash = create_entry(EntryTypes::Person(person.clone()))?;
+    debug!("Person entry created with hash: {:?}", person_hash);
 
     // Create an anchor link for discovering all persons
     let path = Path::from("all_people");
     let anchor_hash = path.path_entry_hash()?;
+    debug!("Creating link from anchor {:?} to person {:?}", anchor_hash, person_hash);
+    
     create_link(
-        anchor_hash,
+        anchor_hash.clone(),
         person_hash.clone(),
         LinkTypes::AllPeople,
         LinkTag::new("person"),
     )?;
+    
+    debug!("Link created successfully for person: {}", person.name);
 
     Ok(CreatePersonOutput {
         person_hash,
@@ -276,25 +282,38 @@ pub fn get_all_agents(_: ()) -> ExternResult<GetAllAgentsOutput> {
     let path = Path::from("all_people");
     let anchor_hash = path.path_entry_hash()?;
 
+    debug!("Getting all agents - anchor hash: {:?}", anchor_hash);
+
     let links =
         get_links(GetLinksInputBuilder::try_new(anchor_hash, LinkTypes::AllPeople)?.build())?;
 
+    debug!("Found {} links for all_people anchor", links.len());
+
     let mut agents = Vec::new();
 
     for link in links {
-        if let Ok(any_dht_hash) = AnyDhtHash::try_from(link.target) {
-            if let Some(record) = get(any_dht_hash, GetOptions::default())? {
+        debug!("Processing link: {:?}", link);
+        if let Ok(any_dht_hash) = AnyDhtHash::try_from(link.target.clone()) {
+            if let Some(record) = get(any_dht_hash.clone(), GetOptions::default())? {
                 if let Ok(Some(EntryTypes::Person(person))) =
                     record.entry().to_app_option::<EntryTypes>().map_err(|_| {
                         wasm_error!(WasmErrorInner::Guest("Failed to deserialize person".into()))
                     })
                 {
+                    debug!("Found person: {}", person.name);
                     agents.push(person);
+                } else {
+                    debug!("Failed to deserialize person from record");
                 }
+            } else {
+                debug!("No record found for hash: {:?}", any_dht_hash);
             }
+        } else {
+            debug!("Failed to convert link target to AnyDhtHash");
         }
     }
 
+    debug!("Returning {} agents", agents.len());
     Ok(GetAllAgentsOutput { agents })
 }