docs: add interface boundary examples to implementation philosophy

Add good/bad examples showing why bypassing public interfaces creates
fragile code. The fix for missing APIs is to extend the interface,
not reach into internal state.

Motivated by microsoft/amplifier-app-cli#70.

🤖 Generated with [Amplifier](https://github.com/microsoft/amplifier)

Co-Authored-By: Amplifier <240397093+microsoft-amplifier@users.noreply.github.com>

Author: colombod

context/IMPLEMENTATION_PHILOSOPHY.md

@@ -295,6 +295,30 @@ class EnhancedMcpClient:
         # [50+ more lines of complex state tracking and retry logic]
 ```
 
+### Bad Example: Bypassing Public Interfaces
+
+```python
+# Reaching into internal state to access what should be exposed publicly
+def get_activator(resolver):
+    # BAD: Unwrapping layers to find internal state
+    bundle_resolver = getattr(resolver, "_bundle", resolver)
+    activator = getattr(bundle_resolver, "_activator", None)
+    return activator
+```
+
+This pattern creates fragile code that breaks when implementations change. Each layer of "unwrapping" compounds the problem.
+
+### Good Example: Respecting Interface Boundaries
+
+```python
+# If you need access to something, extend the public interface
+def get_activator(resolver):
+    # GOOD: Use public API (add one if it doesn't exist)
+    return resolver.get_activator()
+```
+
+**The rule**: If you can't do something through the public interface, the fix is to extend the interface—not bypass it. Accessing internal state (private attributes, wrapped objects) ties your code to implementation details that can change without warning.
+
 ## Remember
 
 - It's easier to add complexity later than to remove it