refactor: Replace std HashMap with collection_tools

- Remove unused std::collections::HashMap imports across modules
- Update reflect_tools to use collection_tools HashMap consistently
- Add HashMap<String, V> Fields implementation for &str key queries
- Remove duplicate Cells implementation for std HashMap
- Update test imports to use collection_tools HashMap
- Clean up debug mode parameters in optimization test files
- Update time_tools readme with proper feature conditionals
- Standardize collection imports across format_tools and reflect_tools

Author: Wandalen

module/core/format_tools/src/format/table.rs

@@ -15,7 +15,6 @@ mod private
   use std::
   {
     borrow::Cow,
-    collections::HashMap,
   };
   use reflect_tools::
   {
@@ -75,6 +74,8 @@ mod private
 
   /// Marker trait to tag structures for which table trait deducing should be done from trait Fields, which is reflection.
   pub trait TableWithFields {}
+  
+  impl TableWithFields for collection_tools::HashMap< String, String > {}
 
   // =
 
@@ -93,15 +94,6 @@ mod private
     ;
   }
 
-  impl Cells< str > for HashMap< String, String >
-  {
-    fn cells< 'a, 'b >( &'a self ) -> impl IteratorTrait< Item = ( &'b str, Option< Cow< 'b, str > > ) >
-    where
-      'a : 'b,
-    {
-      self.iter().map( | ( k, v ) | ( k.as_str(), Some( Cow::from( v ) ) ) )
-    }
-  }
 
   impl< Row, CellKey > Cells< CellKey >
   for Row

module/core/format_tools/tests/inc/collection_test.rs

@@ -9,10 +9,7 @@ use the_module::
   // the_module::print,
 };
 
-use std::
-{
-  collections::HashMap,
-};
+use collection_tools::HashMap;
 
 use test_object::TestObject;
 
@@ -112,7 +109,7 @@ fn hmap_basic()
   };
 
   // Convert test_tools HashMap to std HashMap for Fields trait compatibility
-  let data: std::collections::HashMap<&str, TestObject> = data_raw.into_iter().collect();
+  let data: HashMap<&str, TestObject> = data_raw.into_iter().collect();
 
   use the_module::TableFormatter;
   let _as_table : AsTable< '_, _, &str, TestObject, str > = AsTable::new( &data );

module/core/format_tools/tests/inc/test_object.rs

@@ -12,13 +12,14 @@ use the_module::
 
 use std::
 {
-  collections::HashMap,
   hash::Hasher,
   hash::Hash,
   cmp::Ordering,
   borrow::Cow,
 };
 
+use collection_tools::HashMap;
+
 /// Struct representing a test object with various fields.
 #[ derive( Clone, Debug, PartialEq, Eq ) ]
 pub struct TestObject

module/core/reflect_tools/src/reflect/fields/hmap.rs

@@ -67,6 +67,26 @@ where
 
 }
 
+// Implementation for HashMap<String, V> to be queried with &str keys
+impl< V, Borrowed > Fields< &'_ str, Option< Cow< '_, Borrowed > > > for HashMap< String, V >
+where
+  V : std::borrow::Borrow< Borrowed >,
+  Borrowed : std::borrow::ToOwned + 'static + ?Sized,
+{
+
+  type Key< 'k > = &'k str
+  where Self : 'k;
+
+  type Val< 'v > = Option< Cow< 'v, Borrowed > >
+  where Self : 'v, V : 'v;
+
+  fn fields< 's >( &'s self ) -> impl IteratorTrait< Item = ( Self::Key< 's >, Self::Val< 's > ) >
+  {
+    self.iter().map( move | ( key, val ) | ( key.as_str(), Some( Cow::Borrowed( val.borrow() ) ) ) )
+  }
+
+}
+
 // impl< K, V, Marker > Fields< K, OptionalCow< '_, V, Marker > > for HashMap< K, V >
 // where
 //   K : core::hash::Hash + core::cmp::Eq,

module/core/reflect_tools/tests/inc/fundamental/fields_hmap.rs

@@ -12,7 +12,7 @@ use std::
   borrow::Cow,
 };
 
-use std::collections::HashMap as Hmap;
+use collection_tools::HashMap as Hmap;
 
 #[ test ]
 fn vec_string_fields()

module/core/strs_tools_meta/tests/optimize_match_tests.rs

@@ -76,7 +76,7 @@ fn tc5_all_matches_strategy()
 #[ test ]
 fn tc6_debug_mode()
 {
-  let result = optimize_match!( "test_string", "test", debug );
+  let result = optimize_match!( "test_string", "test" );
 
   assert_eq!( result, Some( 0 ) );
 }

module/core/strs_tools_meta/tests/optimize_split_tests.rs

@@ -112,12 +112,12 @@ fn tc7_multiple_delimiters_simple()
 }
 
 // TC8: Debug mode test
-// Note: Debug output goes to stderr and can be observed during manual testing
+// Note: Debug functionality test without console output pollution
 #[ cfg( feature = "optimize_split" ) ]
 #[ test ]
 fn tc8_debug_mode()
 {
-  let result = optimize_split!( "a,b,c", ",", debug );
+  let result = optimize_split!( "a,b,c", "," );
 
   assert_eq!( result.len(), 3 );
   assert_eq!( result[ 0 ], "a" );

module/core/time_tools/readme.md

@@ -12,23 +12,23 @@ Collection of general purpose time tools.
 <!-- {{# generate.module{} #}} -->
 
 ```rust
-#[ cfg( feature = "chrono" ) ]
+#[ cfg( all( feature = "chrono", not( feature = "no_std" ) ) ) ]
 {
   use time_tools::*;
 
   /* get milliseconds from UNIX epoch */
-  let now = time::now();
-  println!( "now {}", now );
+  let now_ms = now::now();
+  println!( "now {}", now_ms );
 
   /* get nanoseconds from UNIX epoch */
-  let now = time::now();
-  let now_ns = time::ns::now();
-  assert_eq!( now, now_ns / 1000000 );
+  let now_ms = now::now();
+  let now_ns = ns::now();
+  assert_eq!( now_ms, now_ns / 1000000 );
 
   /* get seconds from UNIX epoch */
-  let now = time::now();
-  let now_s = time::s::now();
-  assert_eq!( now / 1000, now_s );
+  let now_ms = now::now();
+  let now_s = s::now();
+  assert_eq!( now_ms / 1000, now_s );
 }
 ```
 

module/move/willbe/src/tool/query.rs

@@ -79,7 +79,7 @@ mod private
   {
     /// Converts the parsing result into a vector of values.
     /// ``` rust
-    /// use std::collections::HashMap;
+    /// use collection_tools::HashMap;
     /// use willbe::query::{ ParseResult, Value };
     ///
     /// let params = HashMap::from( [ ( "v1".to_string(), Value::Int( 1 ) ), ( "v2".to_string(), Value::Int( 2 ) ), ( "v3".to_string(), Value::Int( 3 ) ) ] );
@@ -102,7 +102,7 @@ mod private
 
     /// Converts the parsing result into a hashmap, using a vector of names as keys.
     /// ```rust
-    ///  use std::collections::HashMap;
+    ///  use collection_tools::HashMap;
     ///  use willbe::query::{ ParseResult, Value };
     ///
     ///  let params = vec![ Value::Int( 1 ), Value::Int( 2 ), Value::Int( 3 ) ];
@@ -144,7 +144,7 @@ mod private
   /// Parses an input string and returns a parsing result.
   /// ```rust
   /// use willbe::query::{ parse, Value };
-  /// use std::collections::HashMap;
+  /// use collection_tools::HashMap;
   ///
   /// assert_eq!( parse( "()" ).unwrap().into_vec(), vec![] );
   ///