Add comprehensive type stubs for VersionedKvStore proof and merge functionality (#102)

* Add generate_proof and verify_proof methods to VersionedKvStore

Expose cryptographic proof functionality from ProllyTree to VersionedKvStore
in both Rust and Python APIs for consistent proof generation and verification
across versioned key-value operations.

## Changes

### Rust Implementation
- Add `generate_proof(&self, key: &[u8]) -> Proof<N>` to VersionedKvStore
- Add `verify(&self, proof: Proof<N>, key: &[u8], expected_value: Option<&[u8]>) -> bool`
- Both methods delegate to underlying ProllyTree implementation
- Add comprehensive unit test `test_versioned_store_proof_methods`

### Python Bindings
- Add `generate_proof(key: bytes) -> bytes` to PyVersionedKvStore
- Add `verify_proof(proof_bytes: bytes, key: bytes, expected_value: Optional[bytes]) -> bool`
- Handle proof serialization/deserialization with bincode
- Thread-safe implementation with proper GIL handling

## API Usage

```python
store = VersionedKvStore.open("/path/to/repo")
proof = store.generate_proof(b"key1")
is_valid = store.verify_proof(proof, b"key1", b"value1")
```

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

* Update Python README to document VersionedKvStore proof methods

Add documentation for the newly added generate_proof and verify_proof
methods in the VersionedKvStore example section. Also update the
cryptographic verification feature description to clarify it's
available for both trees and versioned storage.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

* Add comprehensive type stubs for VersionedKvStore proof and merge functionality

Update Python type stubs (.pyi) to include the newly added proof methods
and previously missing merge functionality for better IDE support and
type checking.

## Added Type Stubs

### VersionedKvStore Methods
- `generate_proof(key: bytes) -> bytes` - Generate cryptographic proofs
- `verify_proof(proof: bytes, key: bytes, expected_value: Optional[bytes]) -> bool` - Verify proofs
- `get_commits_for_key(key: bytes) -> List[Dict[str, Union[str, int]]]` - Get key history
- `get_commit_history() -> List[Dict[str, Union[str, int]]]` - Get repository history
- `merge(source_branch: str, conflict_resolution: Optional[ConflictResolution]) -> str` - Merge branches
- `try_merge(source_branch: str) -> Tuple[bool, List[MergeConflict]]` - Attempt merge with conflict detection

### New Classes
- `MergeConflict` - Represents merge conflicts with key, base_value, source_value, destination_value properties
- `ConflictResolution` - Enum with IgnoreAll, TakeSource, TakeDestination strategies

These additions ensure comprehensive IDE support and type checking for all
VersionedKvStore functionality including the newly added proof methods.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

---------

Co-authored-by: Claude <[email protected]>

Author: zhangfengcdt

python/prollytree/prollytree.pyi

@@ -289,6 +289,35 @@ class StorageBackend:
 
     def __str__(self) -> str: ...
 
+class MergeConflict:
+    """Represents a merge conflict between branches"""
+
+    @property
+    def key(self) -> bytes:
+        """The key that has a conflict"""
+        ...
+
+    @property
+    def base_value(self) -> Optional[bytes]:
+        """The value in the common base commit"""
+        ...
+
+    @property
+    def source_value(self) -> Optional[bytes]:
+        """The value in the source branch"""
+        ...
+
+    @property
+    def destination_value(self) -> Optional[bytes]:
+        """The value in the destination branch"""
+        ...
+
+class ConflictResolution:
+    """Enum representing different conflict resolution strategies"""
+    IgnoreAll: "ConflictResolution"
+    TakeSource: "ConflictResolution"
+    TakeDestination: "ConflictResolution"
+
 class VersionedKvStore:
     """A versioned key-value store backed by Git and ProllyTree"""
 
@@ -442,6 +471,61 @@ class VersionedKvStore:
         """
         ...
 
+    def get_commits_for_key(self, key: bytes) -> List[Dict[str, Union[str, int]]]:
+        """
+        Get all commits that contain changes to a specific key.
+
+        Args:
+            key: The key to search for
+
+        Returns:
+            List of commit dictionaries with id, author, committer, message, and timestamp
+        """
+        ...
+
+    def get_commit_history(self) -> List[Dict[str, Union[str, int]]]:
+        """
+        Get the commit history for the repository.
+
+        Returns:
+            List of commit dictionaries with id, author, committer, message, and timestamp
+        """
+        ...
+
+    def merge(
+        self,
+        source_branch: str,
+        conflict_resolution: Optional[ConflictResolution] = None
+    ) -> str:
+        """
+        Merge another branch into the current branch.
+
+        Args:
+            source_branch: Name of the branch to merge from
+            conflict_resolution: Strategy for resolving conflicts (default: IgnoreAll)
+
+        Returns:
+            The commit ID of the merge commit
+
+        Raises:
+            ValueError: If merge fails or has unresolved conflicts
+        """
+        ...
+
+    def try_merge(self, source_branch: str) -> Tuple[bool, List[MergeConflict]]:
+        """
+        Attempt to merge another branch and return any conflicts.
+
+        Args:
+            source_branch: Name of the branch to merge from
+
+        Returns:
+            Tuple of (success, conflicts) where:
+            - success: True if merge succeeded, False if there were conflicts
+            - conflicts: List of MergeConflict objects if success is False
+        """
+        ...
+
     def storage_backend(self) -> StorageBackend:
         """
         Get the current storage backend type.
@@ -450,3 +534,34 @@ class VersionedKvStore:
             Storage backend enum value
         """
         ...
+
+    def generate_proof(self, key: bytes) -> bytes:
+        """
+        Generate a cryptographic proof for a key's existence and value in the versioned store.
+
+        Args:
+            key: The key to generate proof for
+
+        Returns:
+            Serialized proof as bytes
+        """
+        ...
+
+    def verify_proof(
+        self,
+        proof: bytes,
+        key: bytes,
+        expected_value: Optional[bytes] = None
+    ) -> bool:
+        """
+        Verify a cryptographic proof for a key-value pair in the versioned store.
+
+        Args:
+            proof: The serialized proof to verify
+            key: The key that the proof claims to prove
+            expected_value: Optional expected value to verify against
+
+        Returns:
+            True if the proof is valid, False otherwise
+        """
+        ...