refactor(assemblers): Add nodal assembler placeholder

- Implement NodalAssembler placeholder for future GPU implementation
- Add create_cache() stub for NodalCache creation
- Add assemble!() stub with planned algorithm documentation
- Add compute_node_contributions!() stub for node-level assembly
- Document GPU parallelization strategy (one thread per node)
- 178 lines of placeholder and documentation

Planned GPU algorithm:
1. Launch one thread per node
2. Each thread gets touching elements for its node
3. Compute contributions from all touching elements
4. Atomic add to global K, f (thread-safe on GPU)

Expected performance:
- 2-10x speedup on GPU for large problems (> 100k nodes)
- Better cache locality for nodal DOFs
- Natural parallelization pattern

Status:
- Not yet implemented
- Raises error directing users to COO/CSC assemblers
- Will require CUDA.jl or similar GPU framework

src/assemblers/nodal_based.jl

@@ -0,0 +1,177 @@
+# This file is a part of JuliaFEM.
+# License is MIT: see https://github.com/JuliaFEM/JuliaFEM.jl/blob/master/LICENSE.md
+
+"""
+Nodal-based assembly (future implementation).
+
+Node-by-node assembly using inverse connectivity (node-to-elements map).
+Natural for GPU parallelization (one thread per node).
+
+**Performance**: Expected 2-10x speedup on GPU for large problems (> 100k nodes).
+**Best for**: GPU acceleration, very large problems.
+**Status**: Planned for future implementation.
+"""
+
+using SparseArrays
+
+"""
+    assemble!(
+        cache::NodalCache,
+        assembler::NodalAssembler,
+        kernel::AbstractKernel,
+        mesh::AbstractMesh
+    ) -> Nothing
+
+Assemble global system using nodal traversal **in-place, zero allocations**.
+
+**Status**: Not yet implemented. Placeholder for future GPU-based assembly.
+
+# Algorithm (Planned)
+
+1. Reset cache
+2. Loop over nodes (parallelizable on GPU):
+   a. Get all elements touching this node
+   b. For each touching element:
+      - Compute full element stiffness (or use cached value)
+      - Extract only rows/columns for this node
+      - Accumulate to global system (atomic add on GPU)
+
+# GPU Parallelization
+
+Each node processed by one GPU thread:
+```cuda
+__global__ void assemble_nodal(nodes, elements, K, f) {
+    int node_id = blockIdx.x * blockDim.x + threadIdx.x;
+    if (node_id >= nnodes) return;
+
+    // Get touching elements
+    for (elem in touching_elements[node_id]) {
+        // Compute element contribution for this node
+        // Atomic add to K, f
+    }
+}
+```
+
+# Arguments
+- `cache`: Pre-allocated nodal cache
+- `assembler`: Nodal assembler
+- `kernel`: Domain kernel
+- `mesh`: Finite element mesh
+
+# Zero-Allocation Guarantee
+
+All arrays pre-allocated. Atomic operations on GPU ensure thread-safety.
+"""
+function assemble!(
+    cache::NodalCache,
+    assembler::NodalAssembler,
+    kernel::AbstractKernel,
+    mesh::AbstractMesh
+)
+    error("NodalAssembler not yet implemented. Use COOAssembler or CSCAssembler.")
+
+    # Planned implementation:
+    # 1. Reset cache
+    # 2. Loop over nodes
+    # 3. For each node, get touching elements from cache.node_to_elements
+    # 4. Accumulate contributions from all touching elements
+    # 5. Write to global K, f (atomic on GPU)
+
+    return nothing
+end
+
+# ============================================================================
+# HELPER FUNCTIONS (for future implementation)
+# ============================================================================
+
+"""
+    create_cache(assembler::NodalAssembler, mesh::AbstractMesh, kernel::AbstractKernel) -> NodalCache
+
+Create pre-allocated cache for nodal assembly.
+
+Builds node-to-elements map (inverse connectivity) for efficient nodal traversal.
+
+# Arguments
+- `assembler`: Nodal assembler
+- `mesh`: Finite element mesh
+- `kernel`: Domain kernel
+
+# Returns
+- Pre-allocated nodal cache with inverse connectivity
+"""
+function create_cache(assembler::NodalAssembler, mesh::AbstractMesh, kernel::AbstractKernel)
+    return NodalCache(mesh, kernel)
+end
+
+"""
+    compute_node_contributions!(
+        node_cache::NodeCache,
+        element_cache::ElementCache,
+        node_id::Int,
+        kernel::AbstractKernel,
+        mesh::AbstractMesh,
+        node_to_elements::NodeToElementsMap
+    ) -> Nothing
+
+Compute contributions to this node from all touching elements **in-place**.
+
+# Algorithm
+
+1. Get all elements touching this node
+2. For each element:
+   a. Compute full element stiffness (using `compute_element_stiffness!`)
+   b. Find local node index within element
+   c. Extract rows/columns corresponding to this node's DOFs
+   d. Accumulate to node contributions
+
+# Arguments
+- `node_cache`: Node workspace (output)
+- `element_cache`: Element workspace (for kernel calls)
+- `node_id`: Node index
+- `kernel`: Domain kernel
+- `mesh`: Finite element mesh
+- `node_to_elements`: Inverse connectivity
+
+# Returns
+
+Nothing - writes to `node_cache` in-place.
+"""
+function compute_node_contributions!(
+    node_cache::NodeCache,
+    element_cache::ElementCache,
+    node_id::Int,
+    kernel::AbstractKernel,
+    mesh::AbstractMesh,
+    node_to_elements::NodeToElementsMap
+)
+    error("compute_node_contributions! not yet implemented")
+
+    # Planned implementation:
+    # 1. Get touching elements: get_node_spider(node_to_elements, node_id)
+    # 2. For each element:
+    #    - Compute element stiffness: compute_element_stiffness!(element_cache, ...)
+    #    - Find local node index in element
+    #    - Extract node DOF rows/columns from Ke, fe
+    #    - Accumulate to node_cache
+    # 3. Return node_cache (contains all contributions for this node)
+
+    return nothing
+end
+
+# ============================================================================
+# GPU KERNEL STUBS (for future CUDA implementation)
+# ============================================================================
+
+# """
+#     assemble_nodal_gpu!(K, f, mesh, kernel, node_to_elements)
+#
+# GPU kernel for nodal assembly.
+#
+# Launches one thread per node. Each thread:
+# 1. Gets touching elements for its node
+# 2. Computes contributions from all elements
+# 3. Atomically adds to global K, f
+#
+# Requires CUDA.jl or similar GPU framework.
+# """
+# function assemble_nodal_gpu! end