feat(adk): align filesystem backend Path field behavior with Python glob and ls command

Enhanced the filesystem backend to align Path field behavior with Python glob patterns and standard ls command output.
Also improved documentation for enhanced tool call wrapper methods.

Key Changes:

1. Updated FileInfo.Path field documentation:
   - Changed from "absolute path only" to support filename, relative path, or absolute path
   - Clarified that Path value depends on the command context (Ls vs Glob)

2. Modified LsInfo implementation:
   - Returns only filename/directory name instead of full path
   - Uses filepath.Base() for file entries
   - Uses parts[0] for immediate children in directory listings
   - Behavior now matches standard ls command output

3. Enhanced GlobInfo with Python glob compatibility:
   - Replaced custom recursive matching with github.com/bmatcuk/doublestar/v4 library
   - Implemented ** (double star) support for recursive directory traversal
   - Added absolute pattern detection (patterns starting with /)
   - Absolute patterns return absolute paths; relative patterns return relative paths
   - Supports ** in any position: beginning, middle, or end of pattern

4. Comprehensive test coverage:
   - Added TestInMemoryBackend_LsInfo_PathIsFilename: validates Ls returns filenames only
   - Added TestInMemoryBackend_GlobInfo_RelativePath: tests relative/absolute pattern behavior
   - Added TestInMemoryBackend_GlobInfo_RecursivePattern: validates ** recursive matching
   - Updated existing tests to match new Path field behavior

5. Documentation improvements:
   - Added comprehensive documentation for WrapEnhancedInvokableToolCall method
   - Added comprehensive documentation for WrapEnhancedStreamableToolCall method
   - Documentation follows the same pattern as existing WrapInvokableToolCall and WrapStreamableToolCall methods

Technical Implementation:
   - Uses doublestar.Match() for robust glob pattern matching with ** support
   - Pattern matching handles complex patterns like "**/*.go", "src/**/*.go"
   - Absolute patterns (starting with /) bypass basePath filtering and return full paths
   - Relative patterns respect basePath and return paths relative to it

Impact:
   - Ls command now returns clean filenames like standard Unix ls
   - Glob patterns behave identically to Python glob.glob() with recursive=True
   - Supports complex patterns like "**/*.go", "src/**/*.go", and "/absolute/path/**/*.go"
   - Enhanced tool wrapper methods are now properly documented for middleware developers

Author: zhuangjie1125

adk/filesystem/backend.go

@@ -25,7 +25,7 @@ import (
 
 // FileInfo represents basic file metadata information.
 type FileInfo struct {
-	// Path is the absolute path of the file or directory.
+	// Path is the path of the file or directory, which can be a filename, relative path, or absolute path.
 	Path string
 
 	// IsDir indicates whether the entry is a directory.

adk/filesystem/backend_inmemory.go

@@ -25,6 +25,8 @@ import (
 	"strings"
 	"sync"
 	"time"
+
+	"github.com/bmatcuk/doublestar/v4"
 )
 
 type fileEntry struct {
@@ -71,7 +73,7 @@ func (b *InMemoryBackend) LsInfo(ctx context.Context, req *LsInfoRequest) ([]Fil
 				// The path itself is a file
 				if !seen[normalizedFilePath] {
 					result = append(result, FileInfo{
-						Path:       normalizedFilePath,
+						Path:       filepath.Base(normalizedFilePath),
 						IsDir:      false,
 						Size:       int64(len(entry.content)),
 						ModifiedAt: entry.modifiedAt.Format(time.RFC3339Nano),
@@ -94,14 +96,14 @@ func (b *InMemoryBackend) LsInfo(ctx context.Context, req *LsInfoRequest) ([]Fil
 				if !seen[childPath] {
 					if isDir {
 						dirInfo[childPath] = &FileInfo{
-							Path:       childPath,
+							Path:       parts[0],
 							IsDir:      true,
 							Size:       0,
 							ModifiedAt: entry.modifiedAt.Format(time.RFC3339Nano),
 						}
 					} else {
 						result = append(result, FileInfo{
-							Path:       childPath,
+							Path:       parts[0],
 							IsDir:      false,
 							Size:       int64(len(entry.content)),
 							ModifiedAt: entry.modifiedAt.Format(time.RFC3339Nano),
@@ -588,31 +590,40 @@ func (b *InMemoryBackend) GlobInfo(ctx context.Context, req *GlobInfoRequest) ([
 	defer b.mu.RUnlock()
 
 	basePath := normalizePath(req.Path)
+	isAbsolutePattern := strings.HasPrefix(req.Pattern, "/")
 
 	var result []FileInfo
 
 	for filePath, entry := range b.files {
 		normalizedFilePath := normalizePath(filePath)
 
-		if basePath != "/" && !strings.HasPrefix(normalizedFilePath, basePath+"/") && normalizedFilePath != basePath {
-			continue
-		}
+		var matchPath string
+		var resultPath string
 
-		var relativePath string
-		if basePath == "/" {
-			relativePath = strings.TrimPrefix(normalizedFilePath, "/")
+		if isAbsolutePattern {
+			matchPath = normalizedFilePath
+			resultPath = normalizedFilePath
 		} else {
-			relativePath = strings.TrimPrefix(normalizedFilePath, basePath+"/")
+			if basePath != "/" && !strings.HasPrefix(normalizedFilePath, basePath+"/") && normalizedFilePath != basePath {
+				continue
+			}
+
+			if basePath == "/" {
+				matchPath = strings.TrimPrefix(normalizedFilePath, "/")
+			} else {
+				matchPath = strings.TrimPrefix(normalizedFilePath, basePath+"/")
+			}
+			resultPath = matchPath
 		}
 
-		matched, err := filepath.Match(req.Pattern, relativePath)
+		matched, err := doublestar.Match(req.Pattern, matchPath)
 		if err != nil {
 			return nil, fmt.Errorf("invalid glob pattern: %w", err)
 		}
 
 		if matched {
 			result = append(result, FileInfo{
-				Path:       normalizedFilePath,
+				Path:       resultPath,
 				IsDir:      false,
 				Size:       int64(len(entry.content)),
 				ModifiedAt: entry.modifiedAt.Format(time.RFC3339Nano),