Add C# (.NET) binding over the C ABI hub (#226)

The first language stecker on the C ABI hub: a .NET binding exposing all 514
indicators as idiomatic `IDisposable` classes, generated from `wickra.h`.

## What's here

- **`bindings/csharp/`** — the `Wickra` .NET 8 package. `[LibraryImport]`
  source-generated P/Invoke (`NativeMethods.g.cs`) plus idiomatic wrappers
  (`Indicators.g.cs`), both generated from the committed `bindings/c/include/wickra.h`.
  The binding owns no indicator maths — it only marshals types across the C ABI.
- **Marshalling, verified end-to-end against the native library.** Opaque handles
  cross as `nint` kept alive per call via a `SafeHandle`; `bool` as
  `[MarshalAs(U1)]` (Rust `bool` is one byte); a self-correcting
  `DllImportResolver` validates the loaded library actually exports the Wickra
  ABI. Tests cover one representative per FFI archetype (scalar, candle, pairwise,
  multi-output, bars, profile, values-profile, order-book / array-input) plus
  exact Sma reference values.
- **NuGet packaging** — `dotnet pack` produces `Wickra.<version>.nupkg`; the
  release pipeline stages prebuilt native libraries under `runtimes/<rid>/native/`
  for six target triples (win/linux/osx × x64/arm64).
- **`examples/csharp/`** — nine examples mirroring `examples/c/`: streaming,
  backtest, multi_timeframe, parallel_assets, three strategies, and
  fetch_btcusdt + live_binance.
- **CI** — a `csharp` job on the three OSes builds the C ABI, tests the binding,
  and runs the offline examples. **Release** — a gated `csharp-publish` job packs
  and pushes to NuGet (gated on `NUGET_API_KEY`, independent of the GitHub-release
  job so a C# hiccup never blocks the C/C++ asset release).
- **Docs consistency wave** — README, CONTRIBUTING, CHANGELOG, examples/README,
  the issue / PR templates, `sync-about.yml`, and `.gitattributes`.

The native Python / Node / WASM bindings and the C ABI are untouched; this is
additive. Publishing to NuGet stays gated behind the release tag and the secret.

bindings/c/README.md

@@ -1,59 +1,80 @@
-# wickra-c
+# Wickra — C / C++
 
-C ABI for [Wickra](https://github.com/wickra-lib/wickra) — streaming-first
-technical indicators with a Rust core. This crate is the **hub**: it compiles the
+[![CI](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml/badge.svg)](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/wickra-lib/wickra/branch/main/graph/badge.svg)](https://codecov.io/gh/wickra-lib/wickra)
+[![GitHub release](https://img.shields.io/github/v/release/wickra-lib/wickra?logo=github&color=green)](https://github.com/wickra-lib/wickra/releases/latest)
+[![License: MIT OR Apache-2.0](https://img.shields.io/badge/license-MIT_OR_Apache--2.0-blue)](https://github.com/wickra-lib/wickra#license)
+
+**Streaming-first technical indicators for C and C++. A prebuilt shared/static
+library plus a generated `wickra.h` — no system dependencies.**
+
+Wickra is a multi-language technical-analysis library with a Rust core and
+bindings for Python, Node.js and WebAssembly, plus a C ABI for C/C++, C# and any
+other C-capable language. Every indicator is an O(1)
+streaming state machine, so live trading bots and historical backtests share
+the exact same implementation. This package is the **C ABI hub**: it compiles the
 core to a C-compatible shared/static library plus a generated header, so any
 C-capable language (C, C++, Go, C#, Java, R) links against one artifact instead
-of re-wiring every indicator natively.
+of re-wrapping every indicator natively.
 
-The native Python, Node, and WebAssembly bindings are unaffected — this is
-additive, for the ecosystems without first-class Rust tooling.
+## Install
 
-## Artifacts
+Grab the prebuilt header + library for your platform from the
+[GitHub releases](https://github.com/wickra-lib/wickra/releases) — each archive
+has `wickra.h`, the optional `wickra.hpp` C++ wrapper, and the shared/static
+library — or build from source:
 
-```sh
+```bash
 cargo build -p wickra-c --release
+# -> target/release/libwickra.{so,dylib} or wickra.dll (+ import lib) + a staticlib
 ```
 
-- `target/release/libwickra.{so,dylib}` / `wickra.dll` (+ `wickra.dll.lib` import lib on Windows)
-- `target/release/libwickra.a` / `wickra.lib` (static)
-- [`include/wickra.h`](include/wickra.h) — generated by cbindgen, committed.
+Then compile against the header and link the library
+(`cc app.c -I include -L lib -lwickra -lm -o app`).
 
-## API shape
-
-Each indicator is exposed as five `extern "C"` functions over an opaque handle:
+## Quick start
 
 ```c
-struct Sma *wickra_sma_new(uintptr_t period);                 /* NULL on bad params */
-double      wickra_sma_update(struct Sma *h, double value);   /* NaN during warmup */
-void        wickra_sma_batch(struct Sma *h, const double *in, double *out, uintptr_t n);
-void        wickra_sma_reset(struct Sma *h);
-void        wickra_sma_free(struct Sma *h);                   /* exactly once per _new */
+#include "wickra.h"
+
+struct Rsi *rsi = wickra_rsi_new(14);              /* NULL on invalid params */
+for (size_t i = 0; i < n; ++i) {
+    double v = wickra_rsi_update(rsi, prices[i]);  /* NaN during warmup       */
+    if (v == v && v > 70.0)                        /* v == v is the NaN check */
+        printf("overbought\n");
+}
+wickra_rsi_free(rsi);                              /* exactly once per _new   */
 ```
 
-Conventions:
+Every indicator is an opaque handle with the same five functions —
+`_new` / `_update` / `_batch` / `_reset` / `_free`. `update` is O(1); there is no
+RAII across the C boundary, so each `_new` needs exactly one `_free`, and every
+function is NULL-safe (a NULL handle yields `NaN` or a no-op, never a crash).
+Multi-output indicators (MACD, Bollinger, ADX, …) take a pointer to a `#[repr(C)]`
+struct and return a `bool`. The optional `wickra.hpp` wraps any handle in a
+move-only `wickra::Handle` for exception-safe C++ lifetimes.
 
-- **Opaque handles.** `wickra_<ind>_new` returns a `T *` you must release with
-  exactly one `wickra_<ind>_free`. There is no RAII across the boundary.
-- **NaN sentinel.** Scalar outputs return `NaN` while warming up or on a `NULL`
-  handle, mirroring the other bindings — no error codes for the common path.
-- **Caller-owned batch buffers.** `wickra_<ind>_batch` writes one output per
-  input into a buffer you provide; nothing is allocated across the boundary.
-- **NULL-safe.** Every function tolerates a `NULL` handle without crashing.
+## Documentation
 
-## Header regeneration
+The full indicator catalogue, guides, quickstarts, and API reference live in
+the main repository and documentation site:
 
-The header is generated and committed; CI checks it is in sync:
+- **Repository & full indicator list:** <https://github.com/wickra-lib/wickra>
+- **Docs** (C quickstart, cookbook, TA-Lib migration): <https://docs.wickra.org/Quickstart-C>
+- **Runnable examples:** [`examples/c/`](https://github.com/wickra-lib/wickra/tree/main/examples/c)
 
-```sh
-cbindgen --config bindings/c/cbindgen.toml --crate wickra-c --output bindings/c/include/wickra.h
-```
+Wickra ships native bindings for Python, Node.js, WebAssembly and Rust, plus this
+C ABI hub that any C-capable language (C, C++, Go, C#, Java, R) links against —
+all exposing the same indicators from the shared Rust core.
 
-## Examples
+## Disclaimer
 
-Runnable C examples (build via CMake or a direct compiler invocation) live in
-[`examples/c`](../../examples/c).
+Wickra is an indicator toolkit, not a trading system. The values it computes
+are deterministic transforms of the input data — they are not financial advice
+and do not predict the market. Any use in a live trading context is at your own
+risk. The library is provided **as is**, without warranty of any kind.
 
 ## License
 
-`MIT OR Apache-2.0`, the same as the rest of Wickra.
+Licensed under either of [Apache-2.0](https://github.com/wickra-lib/wickra/blob/main/LICENSE-APACHE)
+or [MIT](https://github.com/wickra-lib/wickra/blob/main/LICENSE-MIT) at your option.