chore: log the per-object fallback loads instead of swallowing them silently

`_batch_load_objects()` and its async twin fall back to loading objects one at
a time when the calendar-multiget REPORT fails.  The fallback swallowed every
per-object error with a bare `except Exception: pass`, so a server that failed
both the batch and the individual load left one error-level line about the
batch and no trace at all of what happened to each object.
github-code-quality flagged both handlers - an empty except with neither a log
nor an explanatory comment - on
#694

The swallowing itself is the documented contract: the caller filters on
is_loaded() afterwards, and one unfetchable object must not abort the rest.  So
the behaviour is unchanged and both handlers now say that in a comment, plus a
debug line naming the URL.  Debug rather than warning on purpose - the batch
failure above is already logged at error level, and a large batch would
otherwise emit a wall of warnings for a condition the caller is expected to
handle.  The docstring said "silently swallowing"; it now says what actually
happens.

Prompt: please fix the four findings [of the 17 bot findings on the PR, the four
judged real: the two workflow permission blocks in the previous commit, and
these two empty excepts]

Co-authored-by: Claude Opus 5 <noreply@anthropic.com>

Author: tobixen

caldav/collection.py

@@ -1434,8 +1434,9 @@ def _batch_load_objects(self, objects: list) -> None:
         """Load unloaded objects from the list in a single calendar-multiget REPORT.
 
         Already-loaded objects are skipped.  If the REPORT fails, falls back to
-        individual obj.load(only_if_unloaded=True) calls per object, silently
-        swallowing per-object errors so callers can filter on is_loaded() afterward.
+        individual obj.load(only_if_unloaded=True) calls per object; a per-object
+        failure is logged at debug level and otherwise swallowed, so callers can
+        filter on is_loaded() afterward.
         """
         unloaded = [o for o in objects if not o.is_loaded()]
         if not unloaded:
@@ -1448,7 +1449,13 @@ def _batch_load_objects(self, objects: list) -> None:
                 try:
                     obj.load(only_if_unloaded=True)
                 except Exception:
-                    pass
+                    ## Deliberate: this method's contract is that the caller
+                    ## filters on is_loaded() afterwards, so one object that
+                    ## cannot be fetched must not abort the rest.  Logged at
+                    ## debug rather than warning because the batch failure above
+                    ## is already an error-level line, and a large batch would
+                    ## otherwise produce a wall of warnings.
+                    log.debug("Individual load failed for %s", obj.url, exc_info=True)
 
     async def _async_batch_load_objects(self, objects: list) -> None:
         """Async version of _batch_load_objects.
@@ -1474,7 +1481,9 @@ async def _async_batch_load_objects(self, objects: list) -> None:
                     if inspect.isawaitable(load_result):
                         await load_result
                 except Exception:
-                    pass
+                    ## Same contract as the sync twin above: skip and let the
+                    ## caller filter on is_loaded().
+                    log.debug("Individual load failed for %s", obj.url, exc_info=True)
 
     def calendar_multiget(self, *largs, **kwargs):
         """