```python
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.cpp_extension import load_inline

_cpp_source = """
#include <torch/extension.h>
torch::Tensor fused_activations_cuda(torch::Tensor x, torch::Tensor add);
"""

_cuda_source = r"""
#include <torch/extension.h>
#include <ATen/cuda/CUDAContext.h>
#include <c10/cuda/CUDAGuard.h>
#include <c10/cuda/CUDAException.h>
#include <cuda_runtime.h>
#include <cstdint>
#include <algorithm>

__device__ __forceinline__ float activate(float x, float add) {
    x = x + add;
    x = x * (1.0f / (1.0f + __expf(-x)));
    x = tanhf(x);
    x = (0.5f * x) * (1.0f + erff(x * 0.7071067811865475f));
    return fminf(1.0f, fmaxf(-1.0f, x));
}

__global__ void fused_scalar_kernel(
    const float* __restrict__ x,
    const float* __restrict__ add,
    float* __restrict__ out,
    int64_t count,
    int64_t columns
) {
    for (int64_t i = int64_t(blockIdx.x) * blockDim.x + threadIdx.x;
         i < count;
         i += int64_t(blockDim.x) * gridDim.x) {
        out[i] = activate(x[i], add[i % columns]);
    }
}

__global__ void fused_vector_kernel(
    const float4* __restrict__ x,
    const float4* __restrict__ add,
    float4* __restrict__ out,
    int64_t count,
    int64_t columns
) {
    for (int64_t i = int64_t(blockIdx.x) * blockDim.x + threadIdx.x;
         i < count;
         i += int64_t(blockDim.x) * gridDim.x) {
        float4 v = x[i];
        const float4 a = add[i % columns];
        v.x = activate(v.x, a.x);
        v.y = activate(v.y, a.y);
        v.z = activate(v.z, a.z);
        v.w = activate(v.w, a.w);
        out[i] = v;
    }
}

torch::Tensor fused_activations_cuda(torch::Tensor x, torch::Tensor add) {
    TORCH_CHECK(x.is_cuda() && add.is_cuda(), "Expected CUDA tensors");
    TORCH_CHECK(x.device() == add.device(), "Device mismatch");
    TORCH_CHECK(x.scalar_type() == at::kFloat &&
                add.scalar_type() == at::kFloat, "Expected float32 tensors");
    TORCH_CHECK(x.is_contiguous() && add.is_contiguous(),
                "Expected contiguous tensors");
    TORCH_CHECK(x.dim() >= 1 && add.dim() == 1 &&
                x.size(-1) == add.numel(), "Invalid additive vector");

    const c10::cuda::CUDAGuard guard(x.device());
    auto out = torch::empty_like(x);
    const int64_t count = x.numel();
    if (count == 0) {
        return out;
    }

    const int64_t columns = add.numel();
    const float* xp = x.data_ptr<float>();
    const float* ap = add.data_ptr<float>();
    float* op = out.data_ptr<float>();
    const auto stream = at::cuda::getCurrentCUDAStream();
    constexpr int threads = 256;

    const bool vectorized =
        columns % 4 == 0 &&
        reinterpret_cast<uintptr_t>(xp) % 16 == 0 &&
        reinterpret_cast<uintptr_t>(ap) % 16 == 0 &&
        reinterpret_cast<uintptr_t>(op) % 16 == 0;

    const int64_t work = vectorized ? count / 4 : count;
    const int blocks = static_cast<int>(
        std::min<int64_t>((work + threads - 1) / threads, 4096));

    if (vectorized) {
        fused_vector_kernel<<<blocks, threads, 0, stream>>>(
            reinterpret_cast<const float4*>(xp),
            reinterpret_cast<const float4*>(ap),
            reinterpret_cast<float4*>(op),
            count / 4,
            columns / 4);
    } else {
        fused_scalar_kernel<<<blocks, threads, 0, stream>>>(
            xp, ap, op, count, columns);
    }

    C10_CUDA_KERNEL_LAUNCH_CHECK();
    return out;
}
"""

_fused = load_inline(
    name="linear_swish_tanh_gelu_hardtanh_fused",
    cpp_sources=_cpp_source,
    cuda_sources=_cuda_source,
    functions=["fused_activations_cuda"],
    extra_cflags=["-O3"],
    extra_cuda_cflags=["-O3", "--fmad=false"],
    verbose=False,
)


class _FusedActivations(torch.autograd.Function):
    @staticmethod
    def forward(ctx, x, add):
        if ctx.needs_input_grad[0] or ctx.needs_input_grad[1]:
            ctx.save_for_backward(x, add)
        return _fused.fused_activations_cuda(x, add)

    @staticmethod
    def backward(ctx, grad_output):
        x, add = ctx.saved_tensors
        z = x + add
        sigmoid = torch.sigmoid(z)
        swish = z * sigmoid
        t = torch.tanh(swish)

        gelu_derivative = (
            0.5 * (1.0 + torch.erf(t * 0.7071067811865475))
            + t * torch.exp(-0.5 * t.square()) * 0.3989422804014327
        )
        # GELU(tanh(swish(z))) always lies strictly inside (-1, 1).
        grad = (
            grad_output
            * gelu_derivative
            * (1.0 - t.square())
            * (sigmoid + z * sigmoid * (1.0 - sigmoid))
        )
        grad_x = grad if ctx.needs_input_grad[0] else None
        grad_add = grad.sum_to_size(add.shape) if ctx.needs_input_grad[1] else None
        return grad_x, grad_add


class ModelNew(nn.Module):
    def __init__(self, in_features, out_features, add_value_shape):
        super().__init__()
        self.matmul = nn.Linear(in_features, out_features)
        self.add_value = nn.Parameter(torch.randn(add_value_shape))

    def forward(self, x):
        x = self.matmul(x)
        add = self.add_value

        if (
            x.is_cuda
            and add.device == x.device
            and x.dtype == torch.float32
            and add.dtype == torch.float32
            and x.is_contiguous()
            and add.is_contiguous()
            and add.ndim == 1
            and add.numel() == x.shape[-1]
        ):
            return _FusedActivations.apply(x, add)

        x = x + add
        x = torch.sigmoid(x) * x
        x = torch.tanh(x)
        x = F.gelu(x)
        return F.hardtanh(x, min_val=-1, max_val=1)
```