Add reentrant callbacks for Python→Erlang→Python chains

Implement suspension/resume mechanism that allows Python code to call
Erlang functions which call back into Python without deadlocking.

Key changes:
- Add SuspensionRequired exception for clean Python execution interruption
- Spawn separate processes for callback handling to prevent worker exhaustion
- Support arbitrarily deep nesting (tested up to 10+ levels)
- Fully transparent - erlang.call() works identically from user perspective

New files:
- test/py_reentrant_SUITE.erl: Test suite for reentrant callbacks
- examples/reentrant_demo.erl: Erlang demo with Fibonacci, nested callbacks
- examples/reentrant_demo.py: Python module demonstrating transparent reentrant calls

Author: benoitc

CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 1.2.0 (unreleased)
+
+### Added
+
+- **Reentrant Callbacks** - Python→Erlang→Python callback chains without deadlocks
+  - Exception-based suspension mechanism interrupts Python execution cleanly
+  - Callbacks execute in separate processes to prevent worker pool exhaustion
+  - Supports arbitrarily deep nesting (tested up to 10+ levels)
+  - Transparent to users - `erlang.call()` works the same, just without deadlocks
+  - New test suite: `test/py_reentrant_SUITE.erl`
+  - New examples: `examples/reentrant_demo.erl` and `examples/reentrant_demo.py`
+
+### Changed
+
+- Callback handlers now spawn separate processes for execution, allowing workers
+  to remain available for nested `py:eval`/`py:call` operations
+
 ## 1.1.0 (2026-02-15)
 
 ### Added

README.md

@@ -155,6 +155,40 @@ result = erlang.call('my_func', 10, 20)
 All three methods are equivalent. The import and attribute syntaxes provide
 a more natural Python experience.
 
+### Reentrant Callbacks
+
+Python→Erlang→Python callbacks are fully supported. When Python code calls
+an Erlang function that in turn calls back into Python, the system handles
+this transparently without deadlocking:
+
+```erlang
+%% Register an Erlang function that calls Python
+py:register_function(double_via_python, fun([X]) ->
+    {ok, Result} = py:call('__main__', double, [X]),
+    Result
+end).
+
+%% Define Python functions
+py:exec(<<"
+def double(x):
+    return x * 2
+
+def process(x):
+    from erlang import call
+    # This calls Erlang, which calls Python's double()
+    doubled = call('double_via_python', x)
+    return doubled + 1
+">>).
+
+%% Test the full round-trip
+{ok, 21} = py:call('__main__', process, [10]).
+%% 10 → double_via_python → double(10)=20 → +1 = 21
+```
+
+The implementation uses a suspension/resume mechanism that frees the dirty
+scheduler while the Erlang callback executes, preventing deadlocks even with
+multiple levels of nesting.
+
 ## Shared State Between Workers
 
 Python workers don't share namespace state, but you can share data via the