Please address the comments from this code review:

## Overall Comments
- The retry logic in `_upload_file` uses recursion with a boolean flag; consider replacing this with an explicit, non-recursive retry loop (e.g., a small retry counter) to make the control flow clearer and easier to extend if additional retry cases are added.
- The `registered` flag name and behavior could be clarified (e.g., `has_retried_after_register` or similar) to make it immediately obvious that it is guarding a single retry attempt rather than simply reflecting registration state.

## Individual Comments

### Comment 1
<location path="src/poetry/publishing/uploader.py" line_range="260-264" />
<code_context>
-                    self._register(session, url)
+                    if not registered:
+                        self._register(session, url)
+                        return self._upload_file(
+                            session, url, file, dry_run, skip_existing,
+                            registered=True,
+                        )
</code_context>
<issue_to_address>
**suggestion:** Forwarding all parameters positionally in the recursive call is somewhat brittle.

The retry call currently passes `dry_run` and `skip_existing` positionally. If `_upload_file`’s signature changes (new params or reordered ones), this can silently break behavior. Prefer keyword arguments for these flags and `registered` (e.g. `dry_run=dry_run`, `skip_existing=skip_existing`, `registered=True`) to make the intent explicit and avoid argument ordering issues.

```suggestion
                        self._register(session, url)
                        return self._upload_file(
                            session=session,
                            url=url,
                            file=file,
                            dry_run=dry_run,
                            skip_existing=skip_existing,
                            registered=True,
                        )
```
</issue_to_address>

### Comment 2
<location path="tests/publishing/test_uploader.py" line_range="233-234" />
<code_context>
+) -> None:
+    """After registering a package, the upload must be retried.
+
+    The server returns 400 "was ever registered" on the first upload,
+    then 200 on the registration and the retried upload.
+    """
+    http.post("https://foo.com", status=400, body="No package was ever registered")
</code_context>
<issue_to_address>
**suggestion (testing):** Add a complementary test for repeated 400s after registration to exercise the recursion guard

The current test only covers the case where a 400 leads to registration and then a successful retry. Please add a second test that mocks responses as: 400 (first upload), 200 (register), 400 (retried upload). That test should verify that `upload()` terminates (no further retries/registration attempts) and surfaces the second 400 (e.g., via an exception) instead of attempting to register again.
</issue_to_address>