refactor(testing): make error assertions independent with domain-specific messaging

Convert AssertError and AssertNoError from derived functions that delegate to
nil assertions into independent base functions with error-specific messaging.

Changes:
- AssertError now directly checks err != nil and produces "expected error, got nil".
- AssertNoError now directly checks err == nil and produces "unexpected error: %v".
- Both functions log domain-appropriate success messages.
- Update TESTING_core.md to reflect the new architecture hierarchy.
- Maintain 100% test coverage and all existing tests pass.

This improves clarity when debugging test failures by providing error-oriented
messages rather than generic nil-checking messages.

Signed-off-by: Alejandro Mery <amery@apptly.co>

Author: amery

TESTING_core.md

@@ -22,16 +22,16 @@ Independent Base Functions:
 ├── AssertContains         (uses strings.Contains)
 ├── AssertNil              (uses IsNil utility)
 ├── AssertNotNil           (uses IsNil utility)
+├── AssertError            (standalone implementation)
+├── AssertNoError          (standalone implementation)
 ├── AssertErrorIs          (uses errors.Is)
 ├── AssertTypeIs[T]        (uses type assertion)
 ├── AssertPanic            (uses recover mechanism)
 └── AssertNoPanic          (uses recover mechanism)
 
 Derived Functions (depend on base functions):
 ├── AssertTrue             → calls AssertEqual(t, true, value, ...)
-├── AssertFalse            → calls AssertEqual(t, false, value, ...)
-├── AssertError            → calls AssertNotNil(t, err, ...)
-└── AssertNoError          → calls AssertNil(t, err, ...)
+└── AssertFalse            → calls AssertEqual(t, false, value, ...)
 ```
 
 ### Testing Implications
@@ -85,11 +85,9 @@ The hierarchy exists for consistency and code reuse:
 1. **AssertTrue/AssertFalse → AssertEqual**: Ensures consistent formatting
    and logging behaviour for boolean assertions.
 
-2. **AssertError/AssertNoError → AssertNil/AssertNotNil**: Treats errors as
-   special cases of nil checking with appropriate naming.
-
-3. **Independent Base Functions**: Provide fundamental comparison logic
-   without dependencies on other assertion functions.
+2. **Independent Base Functions**: Provide fundamental comparison logic
+   without dependencies on other assertion functions. Each base function
+   is responsible for its own domain-specific validation and messaging.
 
 This design allows for:
 

testing.go

@@ -355,7 +355,13 @@ func AssertContains(t T, s, substr, name string, args ...any) bool {
 //	AssertError(t, err, "operation %s", "save")
 func AssertError(t T, err error, name string, args ...any) bool {
 	t.Helper()
-	return AssertNotNil(t, err, name, args...)
+	ok := err != nil
+	if !ok {
+		doError(t, name, args, "expected error, got nil")
+	} else {
+		doLog(t, name, args, "error: %v", err)
+	}
+	return ok
 }
 
 // AssertNoError fails the test if error is not nil.
@@ -368,7 +374,13 @@ func AssertError(t T, err error, name string, args ...any) bool {
 //	AssertNoError(t, err, "loading %s", filename)
 func AssertNoError(t T, err error, name string, args ...any) bool {
 	t.Helper()
-	return AssertNil(t, err, name, args...)
+	ok := err == nil
+	if !ok {
+		doError(t, name, args, "unexpected error: %v", err)
+	} else {
+		doLog(t, name, args, "no error")
+	}
+	return ok
 }
 
 // AssertPanic runs a function expecting it to panic and optionally validates the panic value.