docs: add DocumentNavigator development infrastructure and test suite

- Add comprehensive widget plugin infrastructure documentation and workplan
- Include complete DocumentNavigator integration documentation
- Add TDD test suite with 15 comprehensive test cases for DocumentNavigator
- Include widget base classes (Widget, UIWidget) for future development
- Add DocumentNavigator plugin definition following planned architecture
- Include test runner and demo pages for development validation

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

Co-Authored-By: Claude <noreply@anthropic.com>

markitect/static/js/widgets/base/Widget.js

@@ -0,0 +1,141 @@
+/**
+ * Base Widget Class
+ *
+ * Foundation class for all Markitect UI widgets following the plugin architecture.
+ * Provides core functionality for event handling, state management, and lifecycle.
+ */
+export class Widget extends EventTarget {
+    constructor(options = {}) {
+        super();
+
+        // Core properties
+        this.id = options.id || `widget-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        this.container = options.container || document.body;
+        this.config = { ...this.getDefaultConfig(), ...options };
+
+        // State management
+        this.state = new Map();
+        this.isInitialized = false;
+        this.isDestroyed = false;
+
+        // Mixin support
+        this.mixins = [];
+
+        // Lifecycle hooks
+        this.onInitialize = options.onInitialize || (() => {});
+        this.onDestroy = options.onDestroy || (() => {});
+    }
+
+    /**
+     * Initialize the widget
+     */
+    async initialize() {
+        if (this.isInitialized || this.isDestroyed) {
+            return this;
+        }
+
+        try {
+            await this.onInitialize(this);
+            this.isInitialized = true;
+            this.emit('initialized');
+            return this;
+        } catch (error) {
+            this.emit('error', { phase: 'initialize', error });
+            throw error;
+        }
+    }
+
+    /**
+     * Destroy the widget and clean up resources
+     */
+    async destroy() {
+        if (this.isDestroyed) {
+            return;
+        }
+
+        try {
+            await this.onDestroy(this);
+            this.isDestroyed = true;
+            this.emit('destroyed');
+        } catch (error) {
+            this.emit('error', { phase: 'destroy', error });
+            throw error;
+        }
+    }
+
+    /**
+     * State management
+     */
+    setState(key, value) {
+        const oldValue = this.state.get(key);
+        this.state.set(key, value);
+        this.emit('state-changed', { key, value, oldValue });
+    }
+
+    getState(key, defaultValue = null) {
+        return this.state.get(key) ?? defaultValue;
+    }
+
+    /**
+     * Event emission wrapper
+     */
+    emit(eventType, data = {}) {
+        const event = new CustomEvent(eventType, {
+            detail: { widget: this, ...data }
+        });
+        this.dispatchEvent(event);
+    }
+
+    /**
+     * Apply mixin functionality
+     */
+    applyMixin(mixin) {
+        if (typeof mixin === 'object') {
+            Object.assign(this, mixin);
+            this.mixins.push(mixin);
+        }
+        return this;
+    }
+
+    /**
+     * Default configuration (override in subclasses)
+     */
+    getDefaultConfig() {
+        return {};
+    }
+
+    /**
+     * Utility method for creating DOM elements with styling
+     */
+    createElement(tag, options = {}) {
+        const element = document.createElement(tag);
+
+        if (options.className) {
+            element.className = options.className;
+        }
+
+        if (options.textContent) {
+            element.textContent = options.textContent;
+        }
+
+        if (options.innerHTML) {
+            element.innerHTML = options.innerHTML;
+        }
+
+        if (options.style) {
+            if (typeof options.style === 'string') {
+                element.style.cssText = options.style;
+            } else {
+                Object.assign(element.style, options.style);
+            }
+        }
+
+        if (options.attributes) {
+            Object.entries(options.attributes).forEach(([key, value]) => {
+                element.setAttribute(key, value);
+            });
+        }
+
+        return element;
+    }
+}