Since you're new to programming, I'm going to give you more help than you asked for...

First, get your indentation under control. Messy code is hard to read. Almost every IDE has a way to make your code pretty. For VS Code, the Format Document function is your friend. For the Salesforce Developer Console, you can select all your code and use Shift+Tab to make it pretty.

Second, variable names can be 40 characters long. ctct means nothing, while contactName is expressive and clearly tells anyone reading your code what is meant by this. Don't be stingy with your variable names; this isn't the 1980s where you could only use variable names that were 2 letters long.

Third, I'd suggest you avoid using underscores in your LWC names; it makes it so you have to write awkward <c-store_detailz> for no good reason. Use TitleCase for class names, and camelCase for properties. Avoid using excessive uppercase letters, because something like MY_WONDERFUL_PROPERTY will have to be written as -m-y_-w-o-n-d-e-r-f-u-l_-p-r-o-p-e-r-t-y when used in a template, which is not very legible and a pain to type.

Fourth, your Apex can be shortened to just a few lines of code. Here's my rendition of your Apex code:

public class CurrentUserAndContactController {
  @AuraEnabled public static Map<String, String> theMethod() {
    User currentUser = [
      SELECT Contact.Account.Name, Contact.Name 
      FROM User 
      WHERE Id = :UserInfo.getUserId()
    ];
    return new Map<String, String> {
      'accountName' => currentUser.Contact.Account.Name,
      'contactName' => currentUser.Contact.Name
    };
  }
}

Using wrappers are fine, but when you're just getting started learning, keeping things simple is ideal.

Finally, four important things about JavaScript. First, JavaScript is case sensitive. That means that you absolutely need to make sure everything is capitalized correctly everywhere. Second, you need to pay attention to parameters. (Data, Error) is not the same as ({ data, error }). Third, when you reference a variable or function in a class, you always need to use this.. Fourth, you need to remember the structure of your data between the client and server. You tried to access aVar[0], but it should have been something like this.aVar.usr.

Here's my rendition of your controller, noting that I didn't change the component name only to keep things simple.

import { LightningElement, wire, track } from 'lwc';
import theMethod from '@salesforce/apex/CurrentUserandContactController.theMethod';

export default class Store_Detailz extends LightningElement {
    aVar;
    contact;
    user;
    
    @wire(theMethod) userDataHandler({data, error}) {
        if(data) {
            this.aVar = data;
            this.user = data.accountName;
            this.contact = data.contactName;
        }    
    }
}

If you want one generic put method to work, you basically have two options. The first would be to tuck your attributes in a Map.

public class MyWrapper
{
    public Map<String, Object> attributes;
    public MyWrapper put(String key, Object value)
    {
        attributes.put(key, value);
        return this;
    }
}

The other approach would be to use one giant switch statement. Probably not worth the effort, as it doesn't scale well and you'd have to update it every time you add a property.

public MyWrapper put(String key, Object value)
{
    switch on key
    {
        when 'field1' { attribute1 = value; }
        // etc.
    }
}

Alternatively, when I see code similarly structured I would just pass in the SObject instance and set all relevant fields at once. If the wrapper represents just one object, usually in the constructor.

public class MyWrapper
{
    public MyWrapper(MyObject__c record)
    {
        attribute1 = record.Field1__c;
        // etc.
    }
}

You can reference a public inner class like WRAPPER very much like a top level class from a different class such as CLASSTWO using CLASSONE.WRAPPER. An inner class instance is independent of the top level class it is defined in so can be referenced and used very much like a top level class.

It is possible to write a controller extension for a non-standard controller, as Building a Controller Extension mentions, so the extension can reference data from the controller:

// Custom controller
public with sharing class CLASSONE {
    public class WRAPPER {
        // ...
    }
    public list <WRAPPER> wrapObj {get;set;}
    public CLASSONE() {
        WrapObj = new list<wrapper>();
        // List must be populated here if extension is to grab values in its constructor
    }
}

// Custom controller extension
public with sharing class CLASSTWO {
    private CLASSONE c1;
    public CLASSONE.WRAPPER classTwoWrap;
    public CLASSTWO(CLASSONE c1) {
        this.c1 = c1;
        this.classTwoWrap = c1.wrapObj[0];
    }
}

But read documentation such as Considerations for Creating Custom Controllers and Controller Extensions and be aware of Order of Execution for Visualforce Page Get Requests.