fork: reconcile MTP lineage with TurboQuant+ KV cache

Integration glue so the upstream MTP lineage (ggml-org#23198..ggml-org#23398) builds on
this fork without disturbing TurboQuant+ or the custom kernels:

- llama_kv_cache ctor: thread the new `hparams` param and `layer_share_cb`
  through all call sites (iswa, memory-hybrid, dsa, model.cpp); keep the
  fork's turbo auto-asymmetric K upgrade, n_layer_kv() sizing (+3 rotation
  tensors), and per-side LLAMA_ATTN_ROT_* policy (default OFF) — now nested
  under the new `if (other) { share } else { ... }` KV-sharing branch.
- hparams: carry n_layer_all/n_layer_nextn + n_layer()/n_layer_kv() from the
  refactor while keeping the fork's n_layer_kv_from_start; restore the
  swa_layers->is_swa_impl / recurrent_layer_arr->is_recr_impl /
  nextn_predict_layers->n_layer_nextn renames across fork models.
- add n_outputs_max to cparams / common_params / llama_context_params and
  wire it through; restore deepstack_mapping_arr.
- server: keep the ggml-org#23398 ctx_other (MTP draft KV-sharing) wiring; drop the
  ggml-org#23988 --fit VRAM pre-estimation block (depends on upstream helpers not on
  this fork; MTP does not need it).
- drop upstream-only models pulled in by the refactor (deepseek32, mellum,
  talkie); keep non-MTP fork models on their own source + mechanical refactor.

Builds clean on Metal; turbo quant unit test passes (turbo2/3/4 round-trip).
Kernels (ggml-cuda / ggml-metal) untouched.

Author: TheTom

common/common.cpp

@@ -1565,6 +1565,7 @@ struct llama_context_params common_context_params_to_llama(const common_params &
 
     cparams.n_ctx             = params.n_ctx;
     cparams.n_seq_max         = params.n_parallel;
+    cparams.n_outputs_max     = params.n_outputs_max;
     cparams.n_rs_seq          = params.speculative.need_n_rs_seq();
     cparams.n_outputs_max     = std::max(params.n_outputs_max, 0);
     cparams.n_batch           = params.n_batch;

common/common.h

@@ -431,6 +431,7 @@ struct common_params {
     int32_t n_keep                =     0; // number of tokens to keep from initial prompt
     int32_t n_chunks              =    -1; // max number of chunks to process (-1 = unlimited)
     int32_t n_parallel            =     1; // number of parallel sequences to decode
+    int32_t n_outputs_max         =     0; // max outputs supported by the context (0 = derive)
     int32_t n_sequences           =     1; // number of sequences to decode
     int32_t n_outputs_max         =     0; // max outputs in a batch (0 = n_batch)
     int32_t grp_attn_n            =     1; // group-attention factor

include/llama.h

@@ -340,6 +340,7 @@ extern "C" {
         uint32_t n_batch;           // logical maximum batch size that can be submitted to llama_decode
         uint32_t n_ubatch;          // physical maximum batch size
         uint32_t n_seq_max;         // max number of sequences (i.e. distinct states for recurrent models)
+        uint32_t n_outputs_max;     // max outputs supported by the context (0 = derive from n_seq_max)
         uint32_t n_rs_seq;          // number of recurrent-state snapshots per seq for rollback (0 = no rollback) [EXPERIMENTAL]
         uint32_t n_outputs_max;     // max outputs in a ubatch (0 = n_batch)
         int32_t  n_threads;         // number of threads to use for generation

src/llama-context.cpp

@@ -47,6 +47,7 @@ llama_context::llama_context(
     const auto & hparams = model.hparams;
 
     cparams.n_seq_max = std::max(1u, params.n_seq_max);
+    cparams.n_outputs_max = params.n_outputs_max;
     if (cparams.n_seq_max > LLAMA_MAX_SEQ) {
         throw std::runtime_error("n_seq_max must be <= " + std::to_string(LLAMA_MAX_SEQ));
     }
@@ -3446,6 +3447,7 @@ llama_context_params llama_context_default_params() {
         /*.n_batch                     =*/ 2048,
         /*.n_ubatch                    =*/ 512,
         /*.n_seq_max                   =*/ 1,
+        /*.n_outputs_max               =*/ 0,
         /*.n_rs_seq                    =*/ 0,
         /*.n_outputs_max               =*/ 0,
         /*.n_threads                   =*/ GGML_DEFAULT_N_THREADS, // TODO: better default

src/llama-hparams.cpp

@@ -282,6 +282,16 @@ uint32_t llama_hparams::n_layer() const {
     return n_layer_all - n_layer_nextn;
 }
 
+uint32_t llama_hparams::n_layer_kv() const {
+    uint32_t res = 0;
+    for (uint32_t il = 0; il < n_layer(); ++il) {
+        if (has_kv(il)) {
+            res++;
+        }
+    }
+    return res;
+}
+
 bool llama_hparams::use_mrope() const {
     return rope_sections[0] > 0 && rope_sections[1] > 0;
 }

src/llama-hparams.h

@@ -346,6 +346,9 @@ struct llama_hparams {
     // number of effective layers (excludes nextn layers)
     uint32_t n_layer() const;
 
+    // number of layers that carry a KV cache (respects n_layer_kv_from_start)
+    uint32_t n_layer_kv() const;
+
     // note that this function uses different SWA parameters from those in the hparams
     // note: inlined on purpose for performance reasons
     // TODO: think of a better place for this function

src/llama-kv-cache.cpp

@@ -321,15 +321,15 @@ llama_kv_cache::llama_kv_cache(
                     return mode;
                 }
                 // Auto-enable Boundary V (mode 7) when V is turbo2
-                if (type_v == GGML_TYPE_TURBO2_0 && hparams.n_layer >= 8) {
+                if (type_v == GGML_TYPE_TURBO2_0 && hparams.n_layer() >= 8) {
                     LLAMA_LOG_INFO("llama_kv_cache: Boundary V auto-enabled for turbo2-V (opt-out: TURBO_LAYER_ADAPTIVE=0)\n");
                     return 7;
                 }
                 return 0;
             }();
             const bool is_turbo = (type_k == GGML_TYPE_TURBO3_0 || type_k == GGML_TYPE_TURBO4_0 || type_k == GGML_TYPE_TURBO2_0);
             const bool v_is_turbo = (type_v == GGML_TYPE_TURBO3_0 || type_v == GGML_TYPE_TURBO4_0 || type_v == GGML_TYPE_TURBO2_0);
-            const uint32_t n_layer = hparams.n_layer;
+            const uint32_t n_layer = hparams.n_layer();
             if (adaptive_mode == 1 && is_turbo && n_layer >= 8) {
                 if (il < 4 || il >= n_layer - 4) {
                     layer_type_k = GGML_TYPE_Q8_0;