[Feature]: Add database serialization and backup capabilities

## Problem Statement
The ORM doesn't provide built-in database backup and restore capabilities. Users need a way to serialize databases to memory/files and deserialize them for backup, testing, or data migration purposes.

## Proposed Solution
Implement database serialization methods using bun:sqlite's built-in `serialize()` and `deserialize()` capabilities.

## Alternatives Considered
- File-based backup using SQLite's backup API
- Custom export/import functionality
- Third-party backup solutions

## Example Usage
```typescript
// DataSource backup/restore methods
class DataSource {
// Serialize current database to Uint8Array
async backup(): Promise {
return this.database.serialize();
}

// Create new database from serialized data
static async restore(data: Uint8Array, options: DataSourceOptions): Promise {
const database = Database.deserialize(data);
// ... setup new DataSource with restored database
}

// Save backup to file
async backupToFile(filepath: string): Promise {
const data = this.database.serialize();
await Bun.write(filepath, data);
}

// Restore from file
static async restoreFromFile(filepath: string, options: DataSourceOptions): Promise {
const file = Bun.file(filepath);
const data = new Uint8Array(await file.arrayBuffer());
return this.restore(data, options);
}
}

// Usage examples
// Create backup
const backupData = await dataSource.backup();

// Restore to new instance
const restoredDataSource = await DataSource.restore(backupData, {
database: ':memory:',
entities: [User, Post]
});

// File-based backup
await dataSource.backupToFile('./backup.db');
const restored = await DataSource.restoreFromFile('./backup.db', options);
```

## Impact
- Query API: ✗
- Performance: ✗
- Entity definitions: ✗
- Validation: ✗
- Migrations: ✗
- TypeScript types: ✗
- Documentation: ✓

## Additional Context

**Use Cases:**
- Database backups and restore
- Testing with known database states
- Data migration between environments
- In-memory database snapshots
- Development database seeding

**Features to Implement:**
- In-memory serialization (`serialize()`)
- Database restoration (`deserialize()`)
- File-based backup/restore
- Streaming backup for large databases
- Backup validation and integrity checks
- Incremental backup support (future)

**Technical Considerations:**
- Memory usage for large database serialization
- Error handling for corrupted backups
- Schema compatibility between backup and restore
- Performance impact of serialization
- File format and compression options

**SQLite Features Used:**
- `sqlite3_serialize()` - Convert database to memory
- `sqlite3_deserialize()` - Create database from memory
- Built-in data integrity checks

**Priority:** Low - Nice to have feature, not essential for core functionality
**Estimated Impact:** Useful for DevOps and testing workflows

Start by locating the DataSource implementation and its bun:sqlite database setup, then verify the available serialize() and deserialize() APIs. Clarify the initial scope between in-memory and file-based backup/restore, and define done as a working round trip with the issue's integrity, error-handling, and compatibility considerations addressed.

Written by the indexing model from the issue text.