Please address the comments from this code review:
## Overall Comments
- The newly added dependency-groups-schema.json file appears empty; please populate it with the actual JSON schema so that validation of `dependency-groups` works correctly.
- _configure_package_dependencies is becoming quite large and does multiple passes over groups—consider extracting group initialization, constraint parsing, and include handling into smaller helper methods to improve readability and maintainability.
- _resolve_dependency_group_includes currently mutates the input dict in a loop for cycle detection; switching to a dedicated graph‐based algorithm or working on a copy could make the cycle detection logic clearer and side‐effect free.

## Individual Comments

### Comment 1
<location> `src/poetry/core/factory.py:453` </location>
<code_context>
+    ) -> dict[NormalizedName, list[NormalizedName]]:
+        resolved_groups: set[NormalizedName] = set()
+        included: dict[NormalizedName, list[NormalizedName]] = defaultdict(list)
+        while resolved_groups != set(dependency_groups):
+            for group, dependencies in dependency_groups.items():
+                if group in resolved_groups:
</code_context>

<issue_to_address>
Possible infinite loop in _resolve_dependency_group_includes if dependency_groups is malformed.

Consider adding a maximum iteration limit or an explicit error if the loop cannot make progress, to prevent potential infinite loops with malformed input.
</issue_to_address>

### Comment 2
<location> `src/poetry/core/factory.py:466` </location>
<code_context>
+                        resolved_dependencies.append(dep)
+                    else:
+                        included_group = canonicalize_name(dep["include-group"])
+                        if included_group in included[group]:
+                            raise ValueError(
+                                f"Cyclic dependency group include:"
</code_context>

<issue_to_address>
Cyclic dependency group detection may not catch all cycles.

The current logic only detects direct cycles. To handle indirect cycles, implement a more comprehensive cycle detection algorithm, such as depth-first search with a visited set.
</issue_to_address>

### Comment 3
<location> `src/poetry/core/factory.py:700` </location>
<code_context>
         ]
         result["errors"] += tool_poetry_validation_errors

+        dependency_groups = toml_data.get("dependency-groups")
+        if dependency_groups is not None:
+            dependency_groups_validation_errors = [
</code_context>

<issue_to_address>
Validation error messages for dependency-groups may be unclear.

Replacing 'data' with 'dependency-groups' in error messages may not always yield clear results, especially for complex schema errors. Please review the formatting to ensure messages remain accurate and user-friendly.
</issue_to_address>

<suggested_fix>
<<<<<<< SEARCH
            dependency_groups_validation_errors = [
                e.replace("data", "dependency-groups")
                for e in validate_object(dependency_groups, "dependency-groups-schema")
            ]
=======
            dependency_groups_validation_errors = [
                (
                    f"dependency-groups: {e[5:]}" if e.startswith("data:") else
                    e.replace("data", "dependency-groups", 1) if e.startswith("data") else
                    e
                )
                for e in validate_object(dependency_groups, "dependency-groups-schema")
            ]
>>>>>>> REPLACE

</suggested_fix>

### Comment 4
<location> `src/poetry/core/packages/dependency.py:338` </location>
<code_context>

+    @classmethod
+    def _normalize_dependency_group_names(
+        cls,
+        dependency_groups: dict[str, list[str | dict[str, str]]],
+    ) -> dict[NormalizedName, list[str | dict[str, str]]]:
</code_context>

<issue_to_address>
The groups parameter in create_from_pep_508 is not documented.

Please update the docstring to include the groups parameter for clarity.
</issue_to_address>

Please address the comments from this code review:
## Overall Comments
- The nested loops and branching in _configure_package_dependencies are getting quite large—consider splitting the PEP 735 vs legacy group resolution into smaller helper functions or classes to improve readability.
- _add_package_pep735_group_dependencies and _add_package_poetry_group_dependencies share similar logic—unifying or renaming them to better reflect their distinct responsibilities would reduce confusion.
- The duplicate‐name and include‐cycle checks in _validate_dependency_groups are intertwined and hard to follow; extracting them into separate validation helpers could simplify the overall logic.

## Individual Comments

### Comment 1
<location> `src/poetry/core/factory.py:98` </location>
<code_context>
+        dependencies: list[str | dict[str, str]],
+    ) -> list[str]:
+        group_includes = []
+        for constraint in dependencies:
+            if isinstance(constraint, str):
+                dep = Dependency.create_from_pep_508(
+                    constraint,
+                    relative_to=package.root_dir,
+                    groups=[group.pretty_name],
+                )
+                group.add_dependency(dep)
+            else:
+                group_includes.append(constraint["include-group"])
+        return group_includes
+
</code_context>

<issue_to_address>
Potential KeyError if 'include-group' is missing in dict constraint.

Use constraint.get("include-group") and handle the missing key to prevent KeyError exceptions.
</issue_to_address>

### Comment 2
<location> `src/poetry/core/factory.py:397` </location>
<code_context>
+            # with no corresponding entry in dependency-groups
+            # and add dependency information for existing groups
+            poetry_include_groups = {}
+            for group_name, group_config in tool_poetry_groups.items():
+                poetry_include_groups[group_name] = group_config.get(
+                    "include-groups", []
                 )
</code_context>

<issue_to_address>
Possible inconsistency in group name normalization between sources.

Ensure group names are normalized consistently across all sources to prevent mismatches due to case or separator differences.

Suggested implementation:

```python
            poetry_include_groups = {}
+            def _normalize_group_name(name):
+                # Normalize group names: lowercase and replace underscores with dashes
+                return name.lower().replace("_", "-")
+
+            for group_name, group_config in tool_poetry_groups.items():
+                normalized_group_name = _normalize_group_name(group_name)
+                poetry_include_groups[normalized_group_name] = group_config.get(
+                    "include-groups", []
+                )

```

If group names are used elsewhere in this function or file (e.g., when reading from or writing to `poetry_include_groups`), ensure those accesses also use the `_normalize_group_name()` function for consistency.
</issue_to_address>