Fix compute_relative_path coverage gap and note observer.py recursion bugs

The previous compute_relative_path test passed None for ``path`` but
posixpath.relpath silently substitutes ``os.curdir`` for a None start,
so the success branch ran and lines 149-150 (the except + fallback)
stayed uncovered.  Switching to a non-path-like ``file`` argument forces
os.fspath to raise TypeError inside os.path.relpath, which is what the
except clause was written to handle.

Adds a comment at the top of observer_pyt.py explaining why the
self-recursive method bodies in observer.py are deliberately not
covered -- they would recurse until the stack overflows.  The recursion
appears to be a production-code bug; a follow-up commit (outside this
test-only branch) should replace ``self.X(...)`` with ``super().X(...)``
or remove the bodies entirely.

Author: gagelarsen

_package/tests/unit_tests/filesystem_pyt.py

@@ -367,7 +367,8 @@ def test_does_file_exist_swallows_errors(self):
 
     def test_compute_relative_path_swallows_errors(self):
         """compute_relative_path falls back to str(file) when relpath raises."""
-        # None breaks os.path.relpath with TypeError, exercising the except branch.
-        # The fallback returns str(file) with backslashes flipped to forward slashes.
-        result = compute_relative_path(None, 'D:\\some\\path')
-        self.assertEqual('D:/some/path', result)
+        # Passing a non-path-like 'file' argument forces os.path.relpath to raise
+        # (it calls os.fspath on it), exercising the except branch.  The fallback
+        # is ``str(file).replace('\\', '/')`` -- here ``str(12345)`` -> ``'12345'``.
+        result = compute_relative_path('/some/base', 12345)
+        self.assertEqual('12345', result)

_package/tests/unit_tests/observer_pyt.py

@@ -1,6 +1,16 @@
 """
 Test InterpLinear_py.cpp.
 """
+# NOTE on the deliberately-uncovered lines in xms/core/misc/observer.py:
+#
+#   Observer.on_progress_status, on_begin_operation_string, on_end_operation,
+#   on_update_message, time_remaining_in_seconds, and time_elapsed_in_seconds
+#   each have a single-line body that calls the *same* method on ``self`` --
+#   e.g. ``self.on_progress_status(percent_complete)`` inside
+#   ``on_progress_status``.  Invoking any of them directly would recurse
+#   forever, so they cannot be covered by a test.  The tests below sidestep
+#   the issue by overriding every callback in MockObserver.  The recursive
+#   bodies look like a production-code bug and have been flagged for review.
 import time
 import unittest