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

_cpp_source = r"""
#include <torch/extension.h>

torch::Tensor fused_activations_cuda(torch::Tensor x, torch::Tensor add);
"""

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

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

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

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

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(), "Expected matching devices");
    TORCH_CHECK(x.scalar_type() == torch::kFloat32 &&
                add.scalar_type() == torch::kFloat32,
                "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 add vector shape");

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

    const int64_t columns = x.size(-1);
    const float* xp = x.data_ptr<float>();
    const float* ap = add.data_ptr<float>();
    float* op = out.data_ptr<float>();
    const auto stream = c10::cuda::getCurrentCUDAStream(x.get_device());

    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 int64_t needed_blocks = (work + threads - 1) / threads;
    const int blocks = static_cast<int>(
        needed_blocks < 4096 ? needed_blocks : 4096);

    if (vectorized) {
        fused_vector_kernel<<<blocks, threads, 0, stream.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.stream()>>>(
            xp, ap, op, count, columns);
    }

    C10_CUDA_KERNEL_LAUNCH_CHECK();
    return out;
}
"""

_fused_ops = load_inline(
    name="linear_swish_tanh_gelu_hardtanh_fused_v1",
    cpp_sources=_cpp_source,
    cuda_sources=_cuda_source,
    functions=["fused_activations_cuda"],
    extra_cflags=["-O3"],
    extra_cuda_cflags=["-O3"],
    verbose=False,
)


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)
        if (
            x.is_cuda
            and x.dtype == torch.float32
            and self.add_value.dtype == torch.float32
            and x.is_contiguous()
            and self.add_value.is_contiguous()
            and self.add_value.ndim == 1
            and self.add_value.numel() == x.shape[-1]
        ):
            return _fused_ops.fused_activations_cuda(x, self.add_value)

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