Implement comprehensive targeted type-safe improvements across metadata framework

PHASE 2: Add type-safe alternatives alongside existing methods to eliminate unsafe casting

## Core Improvements:

### MetaData.java (+29 lines)
- Add getSuperDataSafe() with Optional return and type checking
- Add addMetaAttrSafe() returning concrete MetaData type
- Add addChildSafe() returning concrete MetaData type
- Maintains backward compatibility while providing type-safe alternatives

### ValidationChain.java (+19 lines)
- Add type-hinted builder() methods with Class<T> parameter
- Enable cleaner type inference: builder(MetaData.class)
- Reduces need for explicit type parameters

### IndexedMetaDataCollection.java (+14 lines)
- Add findByClassSafe() with stream-based filtering and casting
- Eliminates unsafe List<MetaData> to List<T> cast
- Guarantees returned items match specified type

### MetaField.java (+10 lines)
- Add addMetaViewSafe() returning concrete MetaField<T> type
- Eliminates generic T cast in fluent interface

## Benefits Achieved:
✅ Eliminate ClassCastException risks in collection operations
✅ Improve IDE IntelliSense and compile-time type checking
✅ Provide Optional-based APIs for safer null handling
✅ Maintain 100% backward compatibility
✅ All 72 lines of improvements compile and test successfully

No breaking changes - existing code continues to work unchanged while new type-safe alternatives are available for adoption.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: dmealing

metadata/src/main/java/com/draagon/meta/MetaData.java

@@ -520,6 +520,15 @@ public <T extends MetaData> T getSuperData() {
         return (T) superData;
     }
 
+    /**
+     * Gets the Super Data with type safety - returns Optional to avoid ClassCastException
+     * @param type The expected type of the super data
+     * @return Optional containing the super data if it matches the expected type
+     */
+    public <T extends MetaData> Optional<T> getSuperDataSafe(Class<T> type) {
+        return type.isInstance(superData) ? Optional.of(type.cast(superData)) : Optional.empty();
+    }
+
     /**
      * Returns whether this MetaData has a Super MetaData
      * @return SuperData exists
@@ -540,6 +549,16 @@ public <T extends MetaData> T addMetaAttr(MetaAttribute attr) {
         return (T) this;
     }
 
+    /**
+     * Sets an attribute of the MetaClass and returns this MetaData (type-safe version)
+     * @param attr The attribute to add
+     * @return This MetaData instance for method chaining
+     */
+    public MetaData addMetaAttrSafe(MetaAttribute attr) {
+        addChild(attr);
+        return this;
+    }
+
     /**
      * Retrieves an attribute value of the MetaData
      */
@@ -652,6 +671,16 @@ public <T extends MetaData> T addChild(MetaData data) throws InvalidMetaDataExce
         return (T) this;
     }
 
+    /**
+     * Adds a child MetaData object and returns this MetaData (type-safe version)
+     * @param data The child MetaData to add
+     * @return This MetaData instance for method chaining
+     */
+    public MetaData addChildSafe(MetaData data) throws InvalidMetaDataException {
+        addChild(data, true);
+        return this;
+    }
+
     /**
      * Check whether this MetaData is a valid Child to add
      * @param data MetaData to add as a Child

metadata/src/main/java/com/draagon/meta/collections/IndexedMetaDataCollection.java

@@ -162,6 +162,20 @@ public <T extends MetaData> List<T> findByClass(Class<T> clazz) {
         List<MetaData> found = classIndex.getOrDefault(clazz, Collections.emptyList());
         return (List<T>) found;
     }
+
+    /**
+     * Find children by class with type safety - filters and casts safely
+     * 
+     * @param clazz The class to search for
+     * @return List of children guaranteed to be of the specified class
+     */
+    public <T extends MetaData> List<T> findByClassSafe(Class<T> clazz) {
+        List<MetaData> found = classIndex.getOrDefault(clazz, Collections.emptyList());
+        return found.stream()
+            .filter(clazz::isInstance)
+            .map(clazz::cast)
+            .collect(java.util.stream.Collectors.toList());
+    }
 
     /**
      * Find children matching a predicate

metadata/src/main/java/com/draagon/meta/field/MetaField.java

@@ -434,6 +434,16 @@ public <T extends MetaField> T addMetaView(MetaView view) {
         return (T) this;
     }
 
+    /**
+     * Adds a MetaView to this MetaField (type-safe version)
+     * @param view MetaView to add
+     * @return This MetaField instance for method chaining
+     */
+    public MetaField<T> addMetaViewSafe(MetaView view) {
+        addChild(view);
+        return this;
+    }
+
     /**
      * Adds a MetaView to this MetaField
      *

metadata/src/main/java/com/draagon/meta/validation/ValidationChain.java

@@ -206,6 +206,25 @@ public static <T> Builder<T> builder(String chainName) {
         return new Builder<T>().withName(chainName);
     }
 
+    /**
+     * Create a type-hinted builder for cleaner type inference
+     * @param type The class of objects this chain will validate
+     * @return A builder with proper type inference
+     */
+    public static <T> Builder<T> builder(Class<T> type) {
+        return new Builder<>();
+    }
+    
+    /**
+     * Create a named, type-hinted builder for cleaner type inference
+     * @param type The class of objects this chain will validate
+     * @param chainName The name for this validation chain
+     * @return A builder with proper type inference
+     */
+    public static <T> Builder<T> builder(Class<T> type, String chainName) {
+        return new Builder<T>().withName(chainName);
+    }
+    
     /**
      * Builder class for fluent ValidationChain construction
      */