chore(frontend): remove the legacy vanilla-JS frontend and its tooling

The SvelteKit app under /frontend has fully superseded the legacy
vanilla-JS/CSS frontend in /static, which was only ever served by a
debug `cargo run` / `PROFILE=dev` and never shipped to production.
Remove it together with the whole subsystem that existed only to
support it (~54k lines).

Frontend & assets:
- Delete /static (js/, css/, *.html, sw.js, basemaps/, locales symlink).
- Relocate the brand/PWA assets (logo/, favicon.ico, manifest.webmanifest)
  to frontend/static/ so they ship with the SPA. This also fixes the
  favicon, which app.html referenced but was missing from the prod bundle.
- Migrate the Nextcloud login-flow redirects from /nextcloud-error.html
  to the SvelteKit /nextcloud/error route.

Web layer:
- Simplify resolve_static_path: drop the PROFILE=dev branch; always prefer
  the Vite static-dist/ build, fall back to the configured path.
- Resolve i18n locales from the served SPA dir with a frontend/static
  fallback so `just dev` works without a prior build.

Build:
- Prune build.rs from 1262 to ~70 lines (git metadata only); the Rust asset
  pipeline and the OXICLOUD_RUST_ASSETS rollback flag are gone.
- Drop the now-unused build-dependencies (oxc_*, lightningcss).
- Remove the COPY static lines from the Dockerfile (cacher + builder).

Tooling & docs:
- Delete biome.json, jsconfig.json, tools/check-*.py, identifier.sh.
- Remove the legacy front-* justfile recipes; repoint the design-system
  scripts (locales, dead-tokens, brand-drift, token-docs) at the frontend,
  and drop check-contrast/check-headings (coupled to the old token
  taxonomy / multi-page HTML).
- Repoint docs/DESIGN-SYSTEM.md links; remove 5 superseded docs/plan/*.

Backend dead code:
- Remove the dead `folder_repo` field from FileBlobWriteRepository.
- Remove the deprecated GET /api/folders/{id}/listing endpoint
  (superseded by /resources).

Verified: cargo clippy (all-features/all-targets) clean, cargo test
--workspace 448 passed, cargo fmt clean.

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

src/interfaces/api/handlers/folder_handler.rs

@@ -1,12 +1,10 @@
 use axum::{
     Json,
-    body::Body,
     extract::{Path, Query, State},
-    http::{HeaderMap, Response, StatusCode, header},
+    http::{Response, StatusCode, header},
     response::IntoResponse,
 };
 use std::collections::HashMap;
-use std::hash::{Hash, Hasher};
 use std::sync::Arc;
 use tokio_util::io::ReaderStream;
 
@@ -18,10 +16,8 @@ use crate::application::dtos::folder_dto::{
     CreateFolderDto, FolderDto, FolderResourceItemDto, FolderResourcesDto, FolderResourcesQuery,
     ListResourcesOptions, MoveFolderDto, RenameFolderDto,
 };
-use crate::application::dtos::folder_listing_dto::FolderListingDto;
 use crate::application::dtos::grant_dto::{ResourceContentDto, ResourceTypeDto};
 use crate::application::dtos::pagination::PaginationRequestDto;
-use crate::application::ports::file_ports::FileRetrievalUseCase;
 use crate::application::ports::folder_ports::FolderUseCase;
 use crate::application::ports::trash_ports::TrashUseCase;
 use crate::application::services::folder_service::FolderService;
@@ -138,123 +134,6 @@ impl FolderHandler {
         }
     }
 
-    /// Compute a lightweight ETag from the maximum `modified_at` timestamp
-    /// and item count. No body buffering required.
-    fn compute_listing_etag(
-        folders: &[crate::application::dtos::folder_dto::FolderDto],
-        files: &[crate::application::dtos::file_dto::FileDto],
-        favorite_ids: &[String],
-        shared_ids: &[String],
-    ) -> String {
-        let max_mod = folders
-            .iter()
-            .map(|f| f.modified_at)
-            .chain(files.iter().map(|f| f.modified_at))
-            .max()
-            .unwrap_or(0);
-        let count = folders.len() + files.len();
-        let mut hasher = std::collections::hash_map::DefaultHasher::new();
-        max_mod.hash(&mut hasher);
-        count.hash(&mut hasher);
-        // Badge state is part of the representation — fold it in (both slices are
-        // sorted, so the hash is stable) so a favorite/share change busts the ETag.
-        favorite_ids.hash(&mut hasher);
-        shared_ids.hash(&mut hasher);
-        format!("\"{:x}\"", hasher.finish())
-    }
-
-    /// Returns both sub-folders and files for a given folder in a single
-    /// response, eliminating the double-fetch the frontend used to make.
-    ///
-    /// Both queries run concurrently via `tokio::join!`.
-    /// Supports `If-None-Match` / ETag for conditional responses (304).
-    pub(super) async fn list_folder_listing_impl(
-        State(state): State<Arc<GlobalAppState>>,
-        auth_user: AuthUser,
-        headers: HeaderMap,
-        Path(id): Path<String>,
-    ) -> axum::response::Response {
-        let folder_service = &state.applications.folder_service;
-        let file_service = &state.applications.file_retrieval_service;
-
-        // Run both queries concurrently — no sequential wait.
-        let (folders_result, files_result) = tokio::join!(
-            folder_service.list_folders_with_perms(Some(&id), auth_user.id),
-            file_service.list_files_with_perms(Some(&id), auth_user.id)
-        );
-
-        match (folders_result, files_result) {
-            (Ok(folders), Ok(files)) => {
-                // Badge enrichment for this listing: which items the caller has
-                // favorited / shared. Two batched, index-backed queries (run
-                // concurrently) replace the client's old per-navigation global
-                // favorites + outgoing-shares fetches — correct (no 200-item
-                // ceiling) and scoped to just the items on screen.
-                let fav_pairs: Vec<(&str, &str)> = folders
-                    .iter()
-                    .map(|f| (f.id.as_str(), "folder"))
-                    .chain(files.iter().map(|f| (f.id.as_str(), "file")))
-                    .collect();
-                let resource_uuids: Vec<uuid::Uuid> = folders
-                    .iter()
-                    .map(|f| f.id.as_str())
-                    .chain(files.iter().map(|f| f.id.as_str()))
-                    .filter_map(|s| uuid::Uuid::parse_str(s).ok())
-                    .collect();
-
-                let (favorited, shared) = tokio::join!(
-                    async {
-                        match &state.favorites_service {
-                            Some(svc) => svc
-                                .favorited_ids(auth_user.id, &fav_pairs)
-                                .await
-                                .unwrap_or_default(),
-                            None => Default::default(),
-                        }
-                    },
-                    state
-                        .authorization
-                        .shared_resource_ids(auth_user.id, &resource_uuids)
-                );
-
-                let mut favorite_ids: Vec<String> = favorited.into_iter().collect();
-                favorite_ids.sort();
-                let mut shared_ids: Vec<String> = shared
-                    .unwrap_or_default()
-                    .into_iter()
-                    .map(|u| u.to_string())
-                    .collect();
-                shared_ids.sort();
-
-                let etag = Self::compute_listing_etag(&folders, &files, &favorite_ids, &shared_ids);
-
-                // 304 Not Modified if the client already has this version
-                if let Some(inm) = headers.get(header::IF_NONE_MATCH)
-                    && let Ok(client_etag) = inm.to_str()
-                    && client_etag == etag
-                {
-                    return Response::builder()
-                        .status(StatusCode::NOT_MODIFIED)
-                        .header(header::ETAG, &etag)
-                        .body(Body::empty())
-                        .unwrap()
-                        .into_response();
-                }
-                let listing = FolderListingDto {
-                    folders,
-                    files,
-                    favorite_ids,
-                    shared_ids,
-                };
-                let mut resp = (StatusCode::OK, Json(listing)).into_response();
-                resp.headers_mut()
-                    .insert(header::ETAG, header::HeaderValue::from_str(&etag).unwrap());
-                resp
-            }
-            (Err(err), _) | (_, Err(err)) => AppError::from(err).into_response(),
-        }
-    }
-
     /// Renames a folder (ownership enforced).
     pub(super) async fn rename_folder_impl(
         State(service): State<AppState>,
@@ -517,29 +396,6 @@ pub async fn list_root_folders_paginated(
     FolderHandler::list_root_folders_paginated_impl(state, auth_user, pagination).await
 }
 
-#[deprecated = "Use /api/folders/{id}/resources instead"]
-#[utoipa::path(
-    get,
-    path = "/api/folders/{id}/listing",
-    params(("id" = String, Path, description = "Folder ID")),
-    responses(
-        (status = 200, description = "Folder listing (sub-folders + files)", body = FolderListingDto),
-        (status = 304, description = "Not modified"),
-        (status = 404, description = "Folder not found"),
-    ),
-    security(("bearerAuth" = [])),
-    tag = "folders"
-)]
-#[allow(deprecated)]
-pub async fn list_folder_listing(
-    state: State<Arc<GlobalAppState>>,
-    auth_user: AuthUser,
-    headers: HeaderMap,
-    path: Path<String>,
-) -> axum::response::Response {
-    FolderHandler::list_folder_listing_impl(state, auth_user, headers, path).await
-}
-
 #[utoipa::path(
     put,
     path = "/api/folders/{id}/rename",