feat: 6 funciones core — retry, memoize, pipeline, map_concurrent, partition, chunk

Funciones genericas reutilizables:
- RetryWithBackoff: reintento con backoff exponencial (impure)
- Memoize: cache de funciones puras (pure)
- Pipeline: composición T→T en secuencia (pure)
- MapConcurrent: map paralelo con worker pool (impure)
- Partition: divide slice en dos por predicado (pure)
- Chunk: divide slice en trozos de tamaño N (pure)
Todas con implementación real y documentación .md.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

functions/core/map_concurrent.md

@@ -0,0 +1,34 @@
+---
+name: map_concurrent
+kind: function
+lang: go
+domain: core
+version: "1.0.0"
+purity: impure
+signature: "func MapConcurrent[T any, U any](xs []T, fn func(T) U, workers int) []U"
+description: "Aplica una funcion a cada elemento de un slice usando un pool de goroutines como workers. Los resultados preservan el orden original del slice de entrada."
+tags: [map, concurrent, parallel, generic]
+uses_functions: []
+uses_types: []
+returns: []
+returns_optional: false
+error_type: "error_go_core"
+imports: []
+tested: false
+tests: []
+test_file_path: ""
+file_path: "functions/core/map_concurrent.go"
+---
+
+## Ejemplo
+
+```go
+squares := MapConcurrent([]int{1, 2, 3, 4, 5}, func(n int) int {
+    return n * n
+}, 3)
+// squares = [1, 4, 9, 16, 25] (orden preservado)
+```
+
+## Notas
+
+Funcion impura generica que usa goroutines y sync.WaitGroup. Los workers se alimentan de un canal con indices, garantizando que cada resultado se escribe en su posicion correcta sin race conditions (cada goroutine escribe en un indice unico). Si workers <= 0 se usa 1. Si workers > len(xs) se ajusta a len(xs).