Improve normalization logic

Renamed normalizeEntryName to stripLeadingAndTrailingSlashes for better clarity.
Enhanced the normalization logic to handle multiple consecutive leading or trailing slashes. Now, any degenerate entries with multiple slashes are properly stripped to ensure consistent and safe entry paths.
Removed redundant checks for leading or trailing slashes after
normalization. -> Based on Norman Rzepka's suggestion.
Since the normalization process now handles all cases, there's no need for further slash-stripping.

Updated zip entry processing logic to:
Continue using the isDirectory() flag and directoryToChildrenDirectoriesIndex for directory entries.
Unified root directory handling, creating indices, no recursion.

Author: kulvait

src/main/java/dev/zarr/zarrjava/store/ReadOnlyZipStore.java

@@ -107,27 +107,18 @@ private synchronized void buildZipIndex() {
             Enumeration<? extends ZipEntry> en = zf.entries();
             while (en.hasMoreElements()) {
                 ZipEntry e = en.nextElement();
-                String entryStrippedPath = normalizeEntryName(e.getName());
-                if (entryStrippedPath.isEmpty()) continue; // guard against odd entries
-
-                if (e.isDirectory() || entryStrippedPath.endsWith("/")) {
-                    // Ensure directory entryStrippedPaths end with '/' ... this just complicates
-                    if (entryStrippedPath.endsWith("/")) {
-                        entryStrippedPath = entryStrippedPath.substring(0, entryStrippedPath.length() - 1);
-                        logger.log(Level.WARNING,
-                                "Directory entry '{0}' did end with '/' not removed by normalizeEntryName()",
-                                e.getName());
-                    } else if (entryStrippedPath.startsWith("/")) {
-                        entryStrippedPath = entryStrippedPath.substring(1);
-                        logger.log(Level.WARNING,
-                                "Directory entry '{0}' did start with '/' not removed by normalizeEntryName()",
-                                e.getName());
-                    }
+                // In some zip files entries may have leading or trailing slashes, we want to ignore those for consistent indexing
+                // Trailing shashes are common for directory entries, but since we have dedicated directoryToChildrenDirectoriesIndex we strip those and rely on the isDirectory() flag to determine if an entry is a directory or file
+                String entryStrippedPath = stripLeadingAndTrailingSlashes(e.getName());
+
+                if (e.isDirectory()) {
                     directoryToChildrenDirectoriesIndex.computeIfAbsent(entryStrippedPath,
                             k -> ConcurrentHashMap.newKeySet());
                     directoryToChildrenFilesIndex.computeIfAbsent(entryStrippedPath,
                             k -> ConcurrentHashMap.newKeySet());
-                    insertDirectoryEntry(entryStrippedPath);
+                    if (!entryStrippedPath.isEmpty()) { // Don't insert the root directory itself as an entry
+                        insertDirectoryEntry(entryStrippedPath);
+                    }
                 } else {
                     // Put file size (may be -1 for STORED anomalies, but ZipFile usually knows it)
                     long size = e.getSize();
@@ -371,11 +362,12 @@ public Stream<String> listChildren(String[] prefixKeys) {
     }
 
 
-    // Normalize entry names to ensure consistent handling of leading/trailing slashes
-    // Name of root directory will then be ""
-    private String normalizeEntryName(String name) {
-        if (name.startsWith("/")) name = name.substring(1);
-        if (name.endsWith("/")) name = name.substring(0, name.length() - 1);
+    // Strip leading and trailing slashes, including multiple occurrences
+    // For degenerate strings with multiple slashes, they will all be stripped
+    // The name of the root directory will be an empty string ""
+    private String stripLeadingAndTrailingSlashes(String name) {
+        while (name.startsWith("/")) name = name.substring(1);
+        while (name.endsWith("/")) name = name.substring(0, name.length() - 1);
         return name;
     }