Fix pack grouped float and x[template] bugs (+438 tests)

- Fixed grouped float formats producing zeros by adding 'f', 'F', 'd', 'D' to isNumericFormat()
  * Root cause: PackHelper.countValuesNeeded() returned 0 for float formats
  * Impact: pack('(f)2', 1.5, 2.5) was producing zeros instead of correct values

- Fixed x[template] size calculation for complex templates
  * Implemented calculateTemplateSize() using Pack.pack() for accurate size calculation
  * Now correctly handles grouped templates, modifiers, and nested structures

Test improvement: 13,347 → 13,785 passing tests (+438, 3.3% gain)

Author: fglock

src/main/java/org/perlonjava/operators/pack/PackHelper.java

@@ -755,6 +755,7 @@ else if (template.charAt(i) == ')') {
     public static boolean isNumericFormat(char format) {
         return switch (format) {
             case 'c', 'C', 's', 'S', 'l', 'L', 'i', 'I', 'n', 'N', 'v', 'V', 'w', 'W', 'q', 'Q', 'j', 'J',
+                 'f', 'F', 'd', 'D',  // Float and double formats
                  'Z' ->  // Z can be used as a count
                     true;
             default -> false;

src/main/java/org/perlonjava/operators/pack/PackParser.java

@@ -138,9 +138,8 @@ public static ParsedCount parseRepeatCount(String template, int position) {
                     // Empty brackets - treat as count 0
                     result.count = 0;
                 } else {
-                    // Template-based count - for now, use 1 as fallback
-                    result.count = 1;
-                    // TODO: Implement proper template size calculation
+                    // Template-based count - calculate the size of the template
+                    result.count = calculateTemplateSize(countStr);
                 }
 
                 result.endPosition = j;
@@ -329,6 +328,58 @@ private static int countValuesNeeded(String template) {
         return Math.max(count, 10); // Ensure we have at least 10 values
     }
 
+    /**
+     * Calculates the total size in bytes of a template string.
+     * For use with x[template] and X[template] formats.
+     * 
+     * This method uses the actual Pack.pack method to pack dummy data
+     * and measure the resulting size, which handles all complex cases
+     * including groups, modifiers, and nested templates correctly.
+     * 
+     * @param template the template string
+     * @return the total size in bytes
+     */
+    private static int calculateTemplateSize(String template) {
+        // Use the actual pack method to calculate the size by packing dummy data
+        // This handles all complex cases including groups, modifiers, etc.
+        try {
+            // Create a RuntimeList with the template and dummy values
+            org.perlonjava.runtime.RuntimeList args = new org.perlonjava.runtime.RuntimeList();
+            args.add(new org.perlonjava.runtime.RuntimeScalar(template));
+            
+            // Count how many values the template needs and add dummy values
+            int valueCount = countValuesNeeded(template);
+            for (int j = 0; j < valueCount; j++) {
+                // Add dummy values - use 0 for numeric formats
+                args.add(new org.perlonjava.runtime.RuntimeScalar(0));
+            }
+            
+            // Pack with the template and measure the result
+            org.perlonjava.runtime.RuntimeScalar result = org.perlonjava.operators.Pack.pack(args);
+            return result.toString().length();
+        } catch (Exception e) {
+            // If packing fails for any reason, fall back to simple calculation
+            // This might happen for templates with special requirements
+            return calculateTemplateSizeSimple(template);
+        }
+    }
+    
+    /**
+     * Simple fallback calculation for template size.
+     * This is used when the pack method fails for some reason.
+     */
+    private static int calculateTemplateSizeSimple(String template) {
+        // For simple fallback, just count format characters and use default sizes
+        int size = 0;
+        for (int i = 0; i < template.length(); i++) {
+            char c = template.charAt(i);
+            if (Character.isLetter(c) && c != 'X') {  // X is backward, doesn't add size
+                size += getFormatSize(c, false);
+            }
+        }
+        return Math.max(size, 1);  // Return at least 1
+    }
+    
     /**
      * Returns the size in bytes for a given format character.
      *